try parity runner

Co-authored-by: Alexander Theißen <alex.theissen@me.com>

.github/Dockerfile

@@ -0,0 +1,6 @@
+FROM revive-llvm
+
+WORKDIR /app
+
+COPY . .
+RUN RUSTFLAGS='-L /app/llvm18.0/lib/unknown -L /usr/lib -L /app/llvm18.0/lib' REVIVE_INSTALL_DIR='/app/release/revive/' make install-revive

.github/Dockerfile-llvm

@@ -0,0 +1,16 @@
+FROM alpine:3.20.3
+
+ARG RUST_VERSION=stable
+
+RUN apk add bash git cmake make ninja python3 ncurses-static curl
+RUN ninja --version
+
+COPY build-llvm.sh .
+
+RUN bash -c ./build-llvm.sh
+
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain ${RUST_VERSION}
+ENV PATH=/root/.cargo/bin:/llvm18.0/bin:${PATH}
+
+WORKDIR /app
+RUN REVIVE_INSTALL_DIR=$(pwd)/target/release

.github/workflows/build-revive-debian.yml

@@ -0,0 +1,38 @@
+name: Build revive-debian
+on:
+  workflow_dispatch:
+
+env:
+  REVIVE_DEBIAN_PACKAGE: revive-debian-x86
+  DEBIAN_CONTAINER: revive-builder-debian-x86
+  DEBIAN_CONTAINER_BUILDER: build-debian-builder.sh
+  DEBIAN_CONTAINER_RUNNER: run-debian-builder.sh
+  REVIVE_DEBIAN_INSTALL: ${{ github.workspace }}/target/release
+  REVIVE_DEBIAN_BINARY: resolc
+  RUST_VERSION: "1.80"
+
+jobs:
+  build-revive-debian-x86:
+    name: debian-container-x86
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: build-container
+        run: |
+          (cd utils && ./${{ env.DEBIAN_CONTAINER_BUILDER}} --build-arg RUST_VERSION=${{ env.RUST_VERSION}} . )
+
+      - name: build-revive-debian
+        run: |
+          rustup show
+          cargo --version
+          rustup +nightly show
+          cargo +nightly --version
+          bash --version
+          utils/${{ env.DEBIAN_CONTAINER_RUNNER }} utils/build-revive.sh -o ${{ env.REVIVE_DEBIAN_INSTALL}}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.REVIVE_DEBIAN_PACKAGE }}
+          path: ${{ env.REVIVE_DEBIAN_INSTALL }}/${{ env.REVIVE_DEBIAN_BINARY }}
+          retention-days: 1

.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Release
+run-name: Release ${{ github.ref_name }}
+on:
+  push:
+    tags:
+      - "[0-9]+.[0-9]+.[0-9]+"
+      - "[0-9]+.[0-9]+.[0-9]+-[a-zA-Z0-9]+"
+jobs:
+
+  CreateRelease:
+    permissions:
+      contents: write
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          draft: true
+          make_latest: true
+
+  Release:
+    needs: [CreateRelease]
+    permissions:
+      contents: write
+    runs-on: ubuntu-20.04
+    env:
+      GH_TOKEN: ${{ github.token }}
+    steps:
+      - name: build llvm
+        run: docker build -t revive-llvm:latest --progress=plain -f --build-arg RUST_VERSION=1.80 .github/Dockerfile-llvm
+
+      - name: build revive
+        run: docker build -t revive:latest --progress=plain -f .github/Dockerfile
+
+      - name: get binary
+        run: docker run --rm revive:latest -v output:/app/output cp /app/release/revive/resolc /app/output
+
+      # docker push revive:latest
+
+      - run: gh release upload ${{ github.ref_name }} output/resolc --clobber

.github/workflows/rust.yml

@@ -0,0 +1,53 @@
+name: Build
+
+on:
+  push:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build-ubuntu-x86:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install solc
+        run: |
+          mkdir -p solc
+          curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.28/solc-static-linux
+          chmod +x solc/solc
+          echo "$(pwd)/solc/" >> $GITHUB_PATH
+
+      - name: Install LLVM
+        run: |
+          curl -sSL --output llvm.tar.xz https://github.com/llvm/llvm-project/releases/download/llvmorg-18.1.4/clang+llvm-18.1.4-x86_64-linux-gnu-ubuntu-18.04.tar.xz
+          tar Jxf llvm.tar.xz
+          mv clang+llvm-18.1.4-x86_64-linux-gnu-ubuntu-18.04 llvm18/
+          echo "$(pwd)/llvm18/bin" >> $GITHUB_PATH
+
+      - name: Install apt dependencies
+        run: |
+          sudo add-apt-repository -y ppa:ethereum/ethereum
+          sudo apt update
+          sudo apt install -y libtinfo5 ethereum
+
+      - name: Format
+        run: make format
+
+      - name: Clippy
+        run: make clippy
+
+      - name: Test cargo workspace
+        run: make test-workspace
+
+      - name: Test CLI
+        run: make test-cli
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ github.job }}-resolc
+          path: ./target/release/resolc
+          retention-days: 1

.github/workflows/test.yml

@@ -0,0 +1,30 @@
+name: Test
+run-name: Test ${{ github.ref_name }}
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  Release:
+    # runs-on: ubuntu-20.04
+    runs-on: parity-large
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: build llvm
+        run: docker build -t revive-llvm:latest --progress=plain --build-arg RUST_VERSION=1.80 -f .github/Dockerfile-llvm .
+
+      - name: build revive
+        run: docker build -t revive:latest --progress=plain -f .github/Dockerfile
+
+      - name: get binary
+        run: docker run --rm revive:latest -v output:/app/output cp /app/release/revive/resolc /app/output .
+
+      # docker push revive:latest
+
+      - run: gh release upload ${{ github.ref_name }} output/resolc

.gitignore

@@ -12,3 +12,5 @@ node_modules
 artifacts
 tmp
 package-lock.json
+/*.html
+/build

Cargo.toml

@@ -2,7 +2,31 @@
 resolver = "2"
 members = ["crates/*"]
 
+[workspace.package]
+version = "0.1.0"
+authors = [
+    "Cyrill Leutwiler <cyrill@parity.io>",
+    "Parity Technologies <admin@parity.io>",
+]
+license = "MIT/Apache-2.0"
+edition = "2021"
+repository = "https://github.com/paritytech/revive"
+rust-version = "1.80.0"
+
 [workspace.dependencies]
+revive-benchmarks = { version = "0.1.0", path = "crates/benchmarks" }
+revive-builtins = { version = "0.1.0", path = "crates/builtins" }
+revive-common = { version = "0.1.0", path = "crates/common" }
+revive-differential = { version = "0.1.0", path = "crates/differential" }
+revive-integration = { version = "0.1.0", path = "crates/integration" }
+revive-linker = { version = "0.1.0", path = "crates/linker" }
+lld-sys = { version = "0.1.0", path = "crates/lld-sys" }
+revive-llvm-context = { version = "0.1.0", path = "crates/llvm-context" }
+revive-runtime-api = { version = "0.1.0", path = "crates/runtime-api" }
+revive-runner = { version = "0.1.0", path = "crates/runner" }
+revive-solidity = { version = "0.1.0", path = "crates/solidity" }
+revive-stdlib = { version = "0.1.0", path = "crates/stdlib" }
+
 hex = "0.4"
 petgraph = "0.6"
 cc = "1.0"
@@ -25,29 +49,33 @@ thiserror = "1.0"
 which = "5.0"
 path-slash = "0.2"
 rayon = "1.8"
-structopt = { version = "0.3", default-features = false }
+clap = { version = "4", default-features = false, features = ["derive"] }
 rand = "0.8"
-polkavm-common = { git = "https://github.com/koute/polkavm.git", rev = "266658b" } 
+polkavm-common = "0.13"
-polkavm-linker = { git = "https://github.com/koute/polkavm.git", rev = "266658b" } 
+polkavm-linker = "0.13"
-polkavm-disassembler = { git = "https://github.com/koute/polkavm.git", rev = "266658b" }
+polkavm-disassembler = "0.13"
-polkavm = { git = "https://github.com/koute/polkavm.git", rev = "266658b" } 
+polkavm = "0.13"
-alloy-primitives = "0.6"
+alloy-primitives = { version = "0.8", features = ["serde"] }
-alloy-sol-types = "0.6"
+alloy-sol-types = "0.8"
+alloy-genesis = "0.3"
+alloy-serde = "0.3"
 env_logger = { version = "0.10.0", default-features = false }
 serde_stacker = "0.1"
 criterion = { version = "0.5", features = ["html_reports"] }
+log = { version = "0.4" }
 
-# Benchmarking against EVM
+# polkadot-sdk and friends
-primitive-types = { version = "0.12", features = ["codec"] }
+codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
-evm-interpreter = { git = "https://github.com/xermicus/evm.git", branch = "separate-compilation" }
+scale-info = { version = "2.11.1", default-features = false }
+polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "aeebf2f383390f2f86527d70212162d5dbea8b93" }
 
+# llvm
 [workspace.dependencies.inkwell]
-git = "https://github.com/TheDan64/inkwell.git"
+version = "0.5"
-commit = "d916c66"
 default-features = false
 features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
 
-[profile.benchmark]
+[profile.bench]
 inherits = "release"
 lto = true
 codegen-units = 1

Makefile

@@ -1,4 +1,4 @@
-.PHONY: install format test test-solidity test-cli test-integration test-workspace clean
+.PHONY: install format test test-solidity test-cli test-integration test-workspace clean docs docs-build
 
 install: install-bin install-npm
 
@@ -8,11 +8,20 @@ install-bin:
 install-npm:
 	npm install && npm fund
 
+# install-revive: Build and install to the directory specified in REVIVE_INSTALL_DIR
+ifeq ($(origin REVIVE_INSTALL_DIR), undefined)
+REVIVE_INSTALL_DIR=`pwd`/release/revive-debian
+endif
+install-revive:
+	cargo install --path crates/solidity --root $(REVIVE_INSTALL_DIR)
+
 format:
 	cargo fmt --all --check
 
-test: format install test-cli test-workspace
+clippy:
-	cargo test --workspace
+	cargo clippy --all-features --workspace --tests --benches -- --deny warnings --allow dead_code
+
+test: format clippy test-cli test-workspace
 
 test-integration: install-bin
 	cargo test --package revive-integration
@@ -26,27 +35,23 @@ test-workspace: install
 test-cli: install
 	npm run test:cli
 
-bench-prepare: install-bin
+bench-pvm: install-bin
-	cargo criterion --bench prepare --features bench-evm,bench-pvm --message-format=json \
+	cargo criterion --bench execute --features bench-pvm-interpreter --message-format=json \
-	| criterion-table > crates/benchmarks/PREPARE.md
+	| criterion-table > crates/benchmarks/PVM.md
 
-bench-execute: install-bin
+bench-evm: install-bin
-	cargo criterion --bench execute --features bench-evm,bench-pvm --message-format=json \
+	cargo criterion --bench execute --features bench-evm --message-format=json \
-	| criterion-table > crates/benchmarks/EXECUTE.md
+	| criterion-table > crates/benchmarks/EVM.md
 
-bench-extensive: install-bin
+bench: install-bin
 	cargo criterion --all --all-features --message-format=json \
 	| criterion-table > crates/benchmarks/BENCHMARKS.md
 
-bench-quick: install-bin
+docs: docs-build
-	cargo criterion --all --features bench-evm
+	mdbook serve --open docs/
 
-bench: install-bin
+docs-build:
-	cargo criterion --all --features bench-evm,bench-pvm --message-format=json \
+	mdbook test docs/ && mdbook build docs/
-	| criterion-table > crates/benchmarks/BENCHMARKS.md
-
-clippy:
-	cargo clippy --all-features --workspace --tests --benches
 
 clean:
 	cargo clean ; \

README.md

@@ -1,38 +1,38 @@
+![CI](https://github.com/paritytech/revive/actions/workflows/rust.yml/badge.svg)
+
 # revive
 
-YUL and EVM bytecode recompiler to LLVM, targetting RISC-V on PolkaVM.
+YUL and EVM assembly recompiler to LLVM, targetting RISC-V on [PolkaVM](https://github.com/koute/polkavm).
 
-Code bases of [frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are forked and adapted from ZKSync `zksolc`.
+[Frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are based of ZKSync `zksolc`.
 
-# Status
+## Status
 
-Currently, primary goal of this codebase is to allow for benchmarks comparing performance against ink! and solang artifacts as well as EVM interpreters.
+This is experimental software in active development and not ready just yet for production usage.
 
-# TODO
+Discussion around the development is hosted on the [Polkadot Forum](https://forum.polkadot.network/t/contracts-update-solidity-on-polkavm/6949#a-new-solidity-compiler-1).
 
-The project is in a very early PoC phase. Don't yet expect the produced code to be working nor to be correct for anything more than a basic flipper contract at the current stage.
+## Installation
 
-- [ ] Efficient implementations of byte swaps, memset, memmove, mulmod and the like
+`resolc` depends on the [solc](https://github.com/ethereum/solidity) binary installed on your system.
-- [ ] Use `drink` for integration tests once we have 64bit support in PolkaVM
+
-- [x] Use PolkaVM allocator for heap space
+To install the `resolc` Solidity frontend executable:
-- [ ] Exercice `schlau` and possibly `smart-bench` benchmark cases
+
-- [x] Tests currently rely on the binary being in $PATH, which is very annoying and requires `cargo install` all the times
+```bash
-- [ ] Define how to do deployments
+bash build-llvm.sh
-- [ ] Calling conventions for calling other contracts
+export PATH=${PWD}/llvm18.0/bin:$PATH
-- [ ] Runtime environment isn't fully figured out; implement all EVM builtins
+make install-bin
-- [ ] Iron out many leftovers from the ZKVM target
+resolc --version
-    - [ ] Use of exceptions
+```
-    - [ ] Change long calls (contract calls)
+
-    - [ ] Check all alignments, attributes etc. if they still make sense with our target
+### LLVM
-    - [x] Custom extensions related to zk VM
+
-    - [ ] `Active Pointer`: Redundant to calldata forwarding in pallet contracts. [Mainly used here](https://github.com/matter-labs/era-contracts/blob/4aa7006153ad571643342dff22c16eaf4a70fdc1/system-contracts/contracts/libraries/EfficientCall.sol) however we could offer a similar optimization.
+`revive` requires a build of LLVM 18.1.4 or later including `compiler-rt`. Use the provided [build-llvm.sh](build-llvm.sh) build script to compile a compatible LLVM build locally in `$PWD/llvm18.0` (don't forget to add that to `$PATH` afterwards). 
-    - []
+
-- [ ] Add a lot more test cases
+### Development
-- [ ] Debug information
+
-- [ ] Look for and implement further optimizations
+Please consult the [Makefile](Makefile) targets to learn how to run tests and benchmarks. 
-- [ ] Differential testing against EVM
+Ensure that your branch passes `make test` locally when submitting a pull request.
-- [x] Switch to LLVM 18 which has `RV{32,64}E` targets upstream
+
-- [ ] Minimize scope of "stdlib"
+## Design overview
-- [ ] Document differences from EVM
+`revive` uses [solc](https://github.com/ethereum/solidity/), the Ethereum Solidity compiler, as the [Solidity frontend](crates/solidity/src/lib.rs) to process smart contracts written in Solidity. The YUL IR code (or legacy EVM assembly as a fallback for older `solc` versions) emitted by `solc` is then translated to LLVM IR, targetting [Polkadots `revive` pallet](https://docs.rs/pallet-revive/latest/pallet_revive/trait.SyscallDoc.html).
-- [ ] Audit for bugs and correctness
-- [x] Rebranding

build-llvm.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 INSTALL_DIR="${PWD}/llvm18.0"
-mkdir -p $INSTALL_DIR
+mkdir -p ${INSTALL_DIR}
 
 
 # Clone LLVM 18 (any revision after commit bd32aaa is supposed to work)
@@ -13,11 +13,17 @@ fi
 
 
 # Build LLVM, clang
-cd llvm-project
+LLVM_SRC_PREFIX=${PWD}/llvm-project
+LLVM_SRC_DIR=${LLVM_SRC_PREFIX}/llvm
+LLVM_BUILD_DIR=${PWD}/build/llvm
+if [ ! -d ${LLVM_BUILD_DIR} ] ; then
+	mkdir -p ${LLVM_BUILD_DIR}
+fi
 
-mkdir -p build
+cmake -G Ninja \
-cd build
+  -S ${LLVM_SRC_DIR} \
-cmake -G Ninja -DLLVM_ENABLE_ASSERTIONS=On \
+  -B ${LLVM_BUILD_DIR} \
+  -DLLVM_ENABLE_ASSERTIONS=On \
   -DLLVM_ENABLE_TERMINFO=Off \
   -DLLVM_ENABLE_LIBXML2=Off \
   -DLLVM_ENABLE_ZLIB=Off \
@@ -25,45 +31,61 @@ cmake -G Ninja -DLLVM_ENABLE_ASSERTIONS=On \
   -DLLVM_TARGETS_TO_BUILD='RISCV' \
   -DLLVM_ENABLE_ZSTD=Off \
   -DCMAKE_BUILD_TYPE=MinSizeRel \
-  -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \
+  -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR}
-	../llvm
-
-ninja
-ninja install
 
+cmake --build ${LLVM_BUILD_DIR}
+cmake --install ${LLVM_BUILD_DIR}
 
 # Build compiler builtins
-cd ../compiler-rt
+COMPILER_RT_SRC_DIR=${LLVM_SRC_PREFIX}/compiler-rt
-mkdir -p build
+COMPILER_RT_BUILD_DIR=${PWD}/build/compiler-rt
-cd build
+if [ ! -d ${COMPILER_RT_BUILD_DIR} ] ; then
+	mkdir -p ${COMPILER_RT_BUILD_DIR}
+fi
 
-CFLAGS="--target=riscv32 -march=rv32em -mabi=ilp32e -nostdlib -nodefaultlibs -mcpu=generic-rv32"
+build_compiler_rt() {
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=$INSTALL_DIR \
+	case "$1" in
+		64) TARGET_ABI=lp64e ;;
+		32) TARGET_ABI=ilp32e ;;
+		*) exit -1
+	esac
+	CFLAGS="--target=riscv${1} -march=rv${1}em -mabi=${TARGET_ABI} -mcpu=generic-rv${1} -nostdlib -nodefaultlibs"
+
+	cmake -G Ninja \
+	  -S ${COMPILER_RT_SRC_DIR} \
+	  -B ${COMPILER_RT_BUILD_DIR} \
+	  -DCMAKE_BUILD_TYPE=Release \
+	  -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} \
 	  -DCOMPILER_RT_BUILD_BUILTINS=ON \
 	  -DCOMPILER_RT_BUILD_LIBFUZZER=OFF \
 	  -DCOMPILER_RT_BUILD_MEMPROF=OFF \
 	  -DCOMPILER_RT_BUILD_PROFILE=OFF \
 	  -DCOMPILER_RT_BUILD_SANITIZERS=OFF \
 	  -DCOMPILER_RT_BUILD_XRAY=OFF \
-  -DCMAKE_C_COMPILER=$INSTALL_DIR/bin/clang \
+	  -DCMAKE_C_COMPILER=${INSTALL_DIR}/bin/clang \
-  -DCMAKE_C_COMPILER_TARGET="riscv32" \
+	  -DCMAKE_C_COMPILER_TARGET=riscv${1} \
-  -DCMAKE_ASM_COMPILER_TARGET="riscv32" \
+	  -DCMAKE_ASM_COMPILER_TARGET=riscv${1} \
-  -DCMAKE_AR=$INSTALL_DIR/bin/llvm-ar \
+	  -DCMAKE_CXX_COMPILER_TARGET=riscv${1} \
-  -DCMAKE_NM=$INSTALL_DIR/bin/llvm-nm \
+	  -DCMAKE_C_TARGET_BITS=riscv${1} \
-  -DCMAKE_RANLIB=$INSTALL_DIR/bin/llvm-ranlib \
+	  -DCMAKE_ASM_TARGET_BITS=riscv${1} \
+	  -DCMAKE_AR=${INSTALL_DIR}/bin/llvm-ar \
+	  -DCMAKE_NM=${INSTALL_DIR}/bin/llvm-nm \
+	  -DCMAKE_RANLIB=${INSTALL_DIR}/bin/llvm-ranlib \
 	  -DCOMPILER_RT_BAREMETAL_BUILD=ON \
-  -DLLVM_CONFIG_PATH=$INSTALL_DIR/bin/llvm-config \
+	  -DLLVM_CONFIG_PATH=${INSTALL_DIR}/bin/llvm-config \
-  -DCMAKE_C_FLAGS="$CFLAGS" \
+	  -DCMAKE_C_FLAGS="${CFLAGS}" \
-  -DCMAKE_ASM_FLAGS="$CFLAGS" \
+	  -DCMAKE_ASM_FLAGS="${CFLAGS}" \
-  -DCOMPILER_RT_TEST_COMPILER=$INSTALL_DIR/bin/clang \
+	  -DCOMPILER_RT_TEST_COMPILER=${INSTALL_DIR}/bin/clang \
-  -DCMAKE_CXX_FLAGS="$CFLAGS" \
+	  -DCMAKE_CXX_FLAGS="${CFLAGS}" \
-  -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON \
+	  -DCMAKE_SYSTEM_NAME=unknown \
-  -DCMAKE_SYSTEM_NAME=Linux \
+	  -DCOMPILER_RT_DEFAULT_TARGET_ONLY=ON 
-  ..
 	
-ninja
+	cmake --build ${COMPILER_RT_BUILD_DIR}
-ninja install
+	cmake --install ${COMPILER_RT_BUILD_DIR} 
+}
 
+build_compiler_rt 32
+build_compiler_rt 64
 
 echo ""
 echo "success"

crates/benchmarks/BENCHMARKS.md

@@ -8,90 +8,65 @@
     - [TriangleNumber](#trianglenumber)
     - [FibonacciRecursive](#fibonaccirecursive)
     - [FibonacciIterative](#fibonacciiterative)
-    - [PrepareBaseline](#preparebaseline)
+    - [FibonacciBinet](#fibonaccibinet)
-    - [PrepareOddProduct](#prepareoddproduct)
+    - [SHA1](#sha1)
-    - [PrepareTriangleNumber](#preparetrianglenumber)
-    - [PrepareFibonacciRecursive](#preparefibonaccirecursive)
-    - [PrepareFibonacciIterative](#preparefibonacciiterative)
 
 ## Benchmark Results
 
 ### Baseline
 
-|         | `EVM`                     | `PVMInterpreter`                 | `PVM`                             |
+|         | `EVM`                   | `PVMInterpreter`                 |
-|:--------|:--------------------------|:---------------------------------|:--------------------------------- |
+|:--------|:------------------------|:-------------------------------- |
-| **`0`** | `900.78 ns` (✅ **1.00x**) | `715.00 ns` (✅ **1.26x faster**) | `26.22 us` (❌ *29.11x slower*)    |
+| **`0`** | `5.97 us` (✅ **1.00x**) | `27.04 us` (❌ *4.53x slower*)    |
 
 ### OddPorduct
 
-|                 | `EVM`                     | `PVMInterpreter`                 | `PVM`                             |
+|              | `EVM`                     | `PVMInterpreter`                 |
-|:----------------|:--------------------------|:---------------------------------|:--------------------------------- |
+|:-------------|:--------------------------|:-------------------------------- |
-| **`300000`**    | `223.94 ms` (✅ **1.00x**) | `125.43 ms` (✅ **1.79x faster**) | `2.56 ms` (🚀 **87.60x faster**)   |
+| **`10000`**  | `4.26 ms` (✅ **1.00x**)   | `2.88 ms` (✅ **1.48x faster**)   |
-| **`1200000`**   | `907.18 ms` (✅ **1.00x**) | `486.46 ms` (🚀 **1.86x faster**) | `9.96 ms` (🚀 **91.10x faster**)   |
+| **`100000`** | `42.37 ms` (✅ **1.00x**)  | `28.35 ms` (✅ **1.49x faster**)  |
-| **`12000000`**  | `9.41 s` (✅ **1.00x**)    | `4.96 s` (🚀 **1.90x faster**)    | `98.26 ms` (🚀 **95.75x faster**)  |
+| **`300000`** | `127.88 ms` (✅ **1.00x**) | `88.43 ms` (✅ **1.45x faster**)  |
-| **`180000000`** | `133.65 s` (✅ **1.00x**)  | `73.98 s` (🚀 **1.81x faster**)   | `1.48 s` (🚀 **90.04x faster**)    |
-| **`720000000`** | `543.61 s` (✅ **1.00x**)  | `295.27 s` (🚀 **1.84x faster**)  | `6.14 s` (🚀 **88.55x faster**)    |
 
 ### TriangleNumber
 
-|                 | `EVM`                     | `PVMInterpreter`                 | `PVM`                             |
+|              | `EVM`                     | `PVMInterpreter`                 |
-|:----------------|:--------------------------|:---------------------------------|:--------------------------------- |
+|:-------------|:--------------------------|:-------------------------------- |
-| **`360000`**    | `174.29 ms` (✅ **1.00x**) | `134.93 ms` (✅ **1.29x faster**) | `2.58 ms` (🚀 **67.43x faster**)   |
+| **`10000`**  | `2.85 ms` (✅ **1.00x**)   | `2.37 ms` (✅ **1.20x faster**)   |
-| **`1440000`**   | `723.79 ms` (✅ **1.00x**) | `518.44 ms` (✅ **1.40x faster**) | `9.93 ms` (🚀 **72.92x faster**)   |
+| **`100000`** | `27.85 ms` (✅ **1.00x**)  | `23.01 ms` (✅ **1.21x faster**)  |
-| **`14400000`**  | `7.03 s` (✅ **1.00x**)    | `5.40 s` (✅ **1.30x faster**)    | `99.93 ms` (🚀 **70.40x faster**)  |
+| **`360000`** | `103.01 ms` (✅ **1.00x**) | `83.66 ms` (✅ **1.23x faster**)  |
-| **`216000000`** | `108.98 s` (✅ **1.00x**)  | `77.85 s` (✅ **1.40x faster**)   | `1.44 s` (🚀 **75.78x faster**)    |
-| **`864000000`** | `423.03 s` (✅ **1.00x**)  | `323.22 s` (✅ **1.31x faster**)  | `5.99 s` (🚀 **70.61x faster**)    |
 
 ### FibonacciRecursive
 
-|          | `EVM`                     | `PVMInterpreter`                 | `PVM`                              |
+|          | `EVM`                     | `PVMInterpreter`                  |
-|:---------|:--------------------------|:---------------------------------|:---------------------------------- |
+|:---------|:--------------------------|:--------------------------------- |
-| **`24`** | `80.63 ms` (✅ **1.00x**)  | `159.96 ms` (❌ *1.98x slower*)   | `2.73 ms` (🚀 **29.52x faster**)    |
+| **`12`** | `195.19 us` (✅ **1.00x**) | `333.53 us` (❌ *1.71x slower*)    |
-| **`27`** | `331.93 ms` (✅ **1.00x**) | `662.76 ms` (❌ *2.00x slower*)   | `10.78 ms` (🚀 **30.79x faster**)   |
+| **`16`** | `1.22 ms` (✅ **1.00x**)   | `1.97 ms` (❌ *1.62x slower*)      |
-| **`31`** | `2.35 s` (✅ **1.00x**)    | `4.44 s` (❌ *1.88x slower*)      | `76.69 ms` (🚀 **30.69x faster**)   |
+| **`20`** | `8.14 ms` (✅ **1.00x**)   | `13.20 ms` (❌ *1.62x slower*)     |
-| **`36`** | `26.17 s` (✅ **1.00x**)   | `51.08 s` (❌ *1.95x slower*)     | `819.30 ms` (🚀 **31.94x faster**)  |
+| **`24`** | `55.09 ms` (✅ **1.00x**)  | `88.56 ms` (❌ *1.61x slower*)     |
-| **`39`** | `110.50 s` (✅ **1.00x**)  | `220.00 s` (❌ *1.99x slower*)    | `3.46 s` (🚀 **31.90x faster**)     |
 
 ### FibonacciIterative
 
-|                 | `EVM`                     | `PVMInterpreter`                 | `PVM`                              |
+|           | `EVM`                    | `PVMInterpreter`                  |
-|:----------------|:--------------------------|:---------------------------------|:---------------------------------- |
+|:----------|:-------------------------|:--------------------------------- |
-| **`256`**       | `84.27 us` (✅ **1.00x**)  | `291.83 us` (❌ *3.46x slower*)   | `42.87 us` (🚀 **1.97x faster**)    |
+| **`64`**  | `33.39 us` (✅ **1.00x**) | `86.02 us` (❌ *2.58x slower*)     |
-| **`162500`**    | `53.32 ms` (✅ **1.00x**)  | `174.85 ms` (❌ *3.28x slower*)   | `2.57 ms` (🚀 **20.78x faster**)    |
+| **`128`** | `52.91 us` (✅ **1.00x**) | `126.38 us` (❌ *2.39x slower*)    |
-| **`650000`**    | `217.77 ms` (✅ **1.00x**) | `699.77 ms` (❌ *3.21x slower*)   | `9.91 ms` (🚀 **21.96x faster**)    |
+| **`256`** | `82.33 us` (✅ **1.00x**) | `208.74 us` (❌ *2.54x slower*)    |
-| **`6500000`**   | `2.14 s` (✅ **1.00x**)    | `6.89 s` (❌ *3.22x slower*)      | `100.67 ms` (🚀 **21.22x faster**)  |
-| **`100000000`** | `31.96 s` (✅ **1.00x**)   | `106.46 s` (❌ *3.33x slower*)    | `1.50 s` (🚀 **21.28x faster**)     |
-| **`400000000`** | `128.68 s` (✅ **1.00x**)  | `447.34 s` (❌ *3.48x slower*)    | `6.19 s` (🚀 **20.77x faster**)     |
 
-### PrepareBaseline
+### FibonacciBinet
 
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
+|           | `EVM`                    | `PVMInterpreter`                  |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
+|:----------|:-------------------------|:--------------------------------- |
-| **`0`** | `179.68 ns` (✅ **1.00x**) | `506.01 ns` (❌ *2.82x slower*)   | `1.70 us` (❌ *9.45x slower*)         | `29.44 us` (❌ *163.87x slower*)   | `69.01 us` (❌ *384.08x slower*)    |
+| **`64`**  | `32.29 us` (✅ **1.00x**) | `161.75 us` (❌ *5.01x slower*)    |
+| **`128`** | `36.02 us` (✅ **1.00x**) | `172.59 us` (❌ *4.79x slower*)    |
+| **`256`** | `41.21 us` (✅ **1.00x**) | `185.30 us` (❌ *4.50x slower*)    |
 
-### PrepareOddProduct
+### SHA1
 
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                     | `PVMInstantiate`                   |
+|           | `EVM`                     | `PVMInterpreter`                  |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:---------------------------------|:---------------------------------- |
+|:----------|:--------------------------|:--------------------------------- |
-| **`0`** | `509.96 ns` (✅ **1.00x**) | `485.20 ns` (✅ **1.05x faster**) | `1.69 us` (❌ *3.32x slower*)         | `29.88 us` (❌ *58.59x slower*)   | `70.20 us` (❌ *137.66x slower*)    |
+| **`1`**   | `160.17 us` (✅ **1.00x**) | `403.46 us` (❌ *2.52x slower*)    |
-
+| **`64`**  | `286.69 us` (✅ **1.00x**) | `479.79 us` (❌ *1.67x slower*)    |
-### PrepareTriangleNumber
+| **`512`** | `1.18 ms` (✅ **1.00x**)   | `1.37 ms` (❌ *1.16x slower*)      |
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                     | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:---------------------------------|:---------------------------------- |
-| **`0`** | `508.44 ns` (✅ **1.00x**) | `528.74 ns` (✅ **1.04x slower**) | `1.83 us` (❌ *3.60x slower*)         | `50.81 us` (❌ *99.94x slower*)   | `68.37 us` (❌ *134.48x slower*)    |
-
-### PrepareFibonacciRecursive
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
-| **`0`** | `409.24 ns` (✅ **1.00x**) | `507.67 ns` (❌ *1.24x slower*)   | `1.80 us` (❌ *4.40x slower*)         | `46.24 us` (❌ *112.99x slower*)   | `69.06 us` (❌ *168.76x slower*)    |
-
-### PrepareFibonacciIterative
-
-|         | `Evm`                     | `PVMInterpreterCompile`          | `PVMInterpreterInstantiate`          | `PVMCompile`                      | `PVMInstantiate`                   |
-|:--------|:--------------------------|:---------------------------------|:-------------------------------------|:----------------------------------|:---------------------------------- |
-| **`0`** | `304.00 ns` (✅ **1.00x**) | `524.75 ns` (❌ *1.73x slower*)   | `1.88 us` (❌ *6.17x slower*)         | `43.50 us` (❌ *143.11x slower*)   | `66.82 us` (❌ *219.80x slower*)    |
 
 ---
 Made with [criterion-table](https://github.com/nu11ptr/criterion-table)

crates/benchmarks/Cargo.toml

@@ -1,32 +1,28 @@
 [package]
 name = "revive-benchmarks"
-version = "0.1.0"
+version.workspace = true
-edition = "2021"
+license.workspace = true
-authors = [
+edition.workspace = true
-    "Cyrill Leutwiler <cyrill@parity.io>",
+repository.workspace = true
-]
+authors.workspace = true
+description = "revive compiler benchmarks"
 
 [features]
 default = ["bench-pvm-interpreter"]
-bench-pvm-interpreter = []
+bench-pvm-interpreter = ["revive-runner"]
-bench-pvm = []
 bench-evm = ["revive-differential"]
-bench-extensive = []
 
 [dependencies]
 hex = { workspace = true }
-polkavm = { workspace = true }
-revive-integration = { path = "../integration" }
-revive-differential = { path = "../differential", optional = true }
 alloy-primitives = { workspace = true }
 
+revive-integration = { workspace = true }
+revive-differential = { workspace = true, optional = true }
+revive-runner = { workspace = true, optional = true }
+
 [dev-dependencies]
 criterion = { workspace = true }
 
 [[bench]]
 name = "execute"
 harness = false
-
-[[bench]]
-name = "prepare"
-harness = false

crates/benchmarks/benches/execute.rs

@@ -1,62 +1,42 @@
-#[cfg(feature = "bench-extensive")]
+#![cfg(any(feature = "bench-pvm-interpreter", feature = "bench-evm"))]
-use std::time::Duration;
 
+use alloy_primitives::U256;
 use criterion::{
-    criterion_group, criterion_main, measurement::Measurement, BenchmarkGroup, BenchmarkId,
+    criterion_group, criterion_main,
-    Criterion,
+    measurement::{Measurement, WallTime},
+    BenchmarkGroup, BenchmarkId, Criterion,
 };
 use revive_integration::cases::Contract;
 
-fn bench<P, L, I, M>(mut group: BenchmarkGroup<'_, M>, parameters: &[P], labels: &[L], contract: I)
+fn bench<P, L, I>(
-where
+    mut group: BenchmarkGroup<'_, WallTime>,
+    parameters: &[P],
+    labels: &[L],
+    contract: I,
+) where
     P: Clone,
     L: std::fmt::Display,
     I: Fn(P) -> Contract,
-    M: Measurement,
 {
     assert_eq!(parameters.len(), labels.len());
 
+    group.sample_size(10);
+
     for (p, l) in parameters.iter().zip(labels.iter()) {
-        #[cfg(feature = "bench-evm")]
-        {
         let contract = contract(p.clone());
-            let vm = revive_differential::prepare(contract.evm_runtime, contract.calldata);
+
-            group.bench_with_input(BenchmarkId::new("EVM", l), p, move |b, _| {
+        #[cfg(feature = "bench-evm")]
-                b.iter(|| {
+        group.bench_with_input(BenchmarkId::new("EVM", l), p, |b, _| {
-                    revive_differential::execute(vm.clone());
+            let code = &contract.evm_runtime;
+            let input = &contract.calldata;
+            b.iter_custom(|iters| revive_benchmarks::measure_evm(code, input, iters));
         });
-            });
-        }
 
         #[cfg(feature = "bench-pvm-interpreter")]
-        {
-            let contract = contract(p.clone());
-            let (transaction, mut instance, export) = revive_benchmarks::prepare_pvm(
-                &contract.pvm_runtime,
-                contract.calldata,
-                polkavm::BackendKind::Interpreter,
-            );
         group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
-                b.iter(|| {
+            let specs = revive_benchmarks::create_specs(&contract);
-                    transaction.clone().call_on(&mut instance, export);
+            b.iter_custom(|iters| revive_benchmarks::measure_pvm(&specs, iters));
         });
-            });
-        }
-
-        #[cfg(feature = "bench-pvm")]
-        {
-            let contract = contract(p.clone());
-            let (transaction, mut instance, export) = revive_benchmarks::prepare_pvm(
-                &contract.pvm_runtime,
-                contract.calldata,
-                polkavm::BackendKind::Compiler,
-            );
-            group.bench_with_input(BenchmarkId::new("PVM", l), p, |b, _| {
-                b.iter(|| {
-                    transaction.clone().call_on(&mut instance, export);
-                });
-            });
-        }
     }
 
     group.finish();
@@ -66,16 +46,6 @@ fn group<'error, M>(c: &'error mut Criterion<M>, group_name: &str) -> BenchmarkG
 where
     M: Measurement,
 {
-    #[cfg(feature = "bench-extensive")]
-    {
-        let mut group = c.benchmark_group(group_name);
-        group
-            .sample_size(10)
-            .measurement_time(Duration::from_secs(60));
-        group
-    }
-
-    #[cfg(not(feature = "bench-extensive"))]
     return c.benchmark_group(group_name);
 }
 
@@ -88,49 +58,46 @@ fn bench_baseline(c: &mut Criterion) {
 
 fn bench_odd_product(c: &mut Criterion) {
     let group = group(c, "OddPorduct");
-    #[cfg(feature = "bench-extensive")]
+    let parameters = &[10_000, 100_000, 300000];
-    let parameters = &[300000, 1200000, 12000000, 180000000, 720000000];
-    #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[10_000, 100_000];
 
     bench(group, parameters, parameters, Contract::odd_product);
 }
 
 fn bench_triangle_number(c: &mut Criterion) {
     let group = group(c, "TriangleNumber");
-    #[cfg(feature = "bench-extensive")]
+    let parameters = &[10_000, 100_000, 360000];
-    let parameters = &[360000, 1440000, 14400000, 216000000, 864000000];
-    #[cfg(not(feature = "bench-extensive"))]
-    let parameters = &[10_000, 100_000];
 
     bench(group, parameters, parameters, Contract::triangle_number);
 }
 
 fn bench_fibonacci_recurisve(c: &mut Criterion) {
     let group = group(c, "FibonacciRecursive");
-    #[cfg(feature = "bench-extensive")]
+    let parameters = [12, 16, 20, 24]
-    let parameters = &[24, 27, 31, 36, 39];
+        .iter()
-    #[cfg(not(feature = "bench-extensive"))]
+        .map(|p| U256::from(*p))
-    let parameters = &[12, 16, 20];
+        .collect::<Vec<_>>();
 
-    bench(group, parameters, parameters, Contract::fib_recursive);
+    bench(group, &parameters, &parameters, Contract::fib_recursive);
 }
 
 fn bench_fibonacci_iterative(c: &mut Criterion) {
     let group = group(c, "FibonacciIterative");
-    #[cfg(feature = "bench-extensive")]
+    let parameters = [64, 128, 256]
-    let parameters = &[256, 162500, 650000, 6500000, 100000000, 400000000];
+        .iter()
-    #[cfg(not(feature = "bench-extensive"))]
+        .map(|p| U256::from(*p))
-    let parameters = &[64, 128, 256];
+        .collect::<Vec<_>>();
 
-    bench(group, parameters, parameters, Contract::fib_iterative);
+    bench(group, &parameters, &parameters, Contract::fib_iterative);
 }
 
 fn bench_fibonacci_binet(c: &mut Criterion) {
     let group = group(c, "FibonacciBinet");
-    let parameters = &[64, 128, 256];
+    let parameters = [64, 128, 256]
+        .iter()
+        .map(|p| U256::from(*p))
+        .collect::<Vec<_>>();
 
-    bench(group, parameters, parameters, Contract::fib_binet);
+    bench(group, &parameters, &parameters, Contract::fib_binet);
 }
 
 fn bench_sha1(c: &mut Criterion) {
@@ -138,7 +105,9 @@ fn bench_sha1(c: &mut Criterion) {
     let parameters = &[vec![0xff], vec![0xff; 64], vec![0xff; 512]];
     let labels = parameters.iter().map(|p| p.len()).collect::<Vec<_>>();
 
-    bench(group, parameters, &labels, Contract::sha1);
+    bench(group, parameters, &labels, |input| {
+        Contract::sha1(input.into())
+    });
 }
 
 criterion_group!(

crates/benchmarks/benches/prepare.rs

@@ -1,170 +0,0 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-
-use revive_integration::cases::Contract;
-
-fn bench(
-    c: &mut Criterion,
-    group_name: &str,
-    #[cfg(feature = "bench-evm")] evm_runtime: Vec<u8>,
-    #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))] pvm_runtime: Vec<u8>,
-) {
-    let mut group = c.benchmark_group(group_name);
-    let code_size = 0;
-
-    #[cfg(feature = "bench-evm")]
-    group.bench_with_input(
-        BenchmarkId::new("Evm", code_size),
-        &evm_runtime,
-        |b, code| b.iter(|| revive_differential::prepare(code.clone(), Vec::new())),
-    );
-
-    #[cfg(feature = "bench-pvm-interpreter")]
-    {
-        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Interpreter);
-        group.bench_with_input(
-            BenchmarkId::new("PVMInterpreterCompile", code_size),
-            &(&pvm_runtime, engine),
-            |b, (code, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::recompile_code(code, engine);
-                });
-            },
-        );
-    }
-
-    #[cfg(feature = "bench-pvm-interpreter")]
-    {
-        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Interpreter);
-        let module = revive_integration::mock_runtime::recompile_code(&pvm_runtime, &engine);
-        group.bench_with_input(
-            BenchmarkId::new("PVMInterpreterInstantiate", code_size),
-            &(module, engine),
-            |b, (module, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::instantiate_module(module, engine);
-                });
-            },
-        );
-    }
-
-    #[cfg(feature = "bench-pvm")]
-    {
-        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Compiler);
-        group.bench_with_input(
-            BenchmarkId::new("PVMCompile", code_size),
-            &(&pvm_runtime, engine),
-            |b, (code, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::recompile_code(code, engine);
-                });
-            },
-        );
-    }
-
-    #[cfg(feature = "bench-pvm")]
-    {
-        let engine = revive_benchmarks::instantiate_engine(polkavm::BackendKind::Compiler);
-        let module = revive_integration::mock_runtime::recompile_code(&pvm_runtime, &engine);
-        group.bench_with_input(
-            BenchmarkId::new("PVMInstantiate", code_size),
-            &(module, engine),
-            |b, (module, engine)| {
-                b.iter(|| {
-                    revive_integration::mock_runtime::instantiate_module(module, engine);
-                });
-            },
-        );
-    }
-
-    group.finish();
-}
-
-fn bench_baseline(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareBaseline",
-        #[cfg(feature = "bench-evm")]
-        Contract::baseline().evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::baseline().pvm_runtime,
-    );
-}
-
-fn bench_odd_product(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareOddProduct",
-        #[cfg(feature = "bench-evm")]
-        Contract::odd_product(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::baseline().pvm_runtime,
-    );
-}
-
-fn bench_triangle_number(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareTriangleNumber",
-        #[cfg(feature = "bench-evm")]
-        Contract::triangle_number(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::triangle_number(0).pvm_runtime,
-    );
-}
-
-fn bench_fibonacci_recursive(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareFibonacciRecursive",
-        #[cfg(feature = "bench-evm")]
-        Contract::fib_recursive(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_recursive(0).pvm_runtime,
-    );
-}
-
-fn bench_fibonacci_iterative(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareFibonacciIterative",
-        #[cfg(feature = "bench-evm")]
-        Contract::fib_iterative(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_iterative(0).pvm_runtime,
-    );
-}
-
-fn bench_fibonacci_binet(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareFibonacciBinet",
-        #[cfg(feature = "bench-evm")]
-        Contract::fib_binet(0).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::fib_binet(0).pvm_runtime,
-    );
-}
-
-fn bench_sha1(c: &mut Criterion) {
-    bench(
-        c,
-        "PrepareSHA1",
-        #[cfg(feature = "bench-evm")]
-        Contract::sha1(Default::default()).evm_runtime,
-        #[cfg(any(feature = "bench-pvm-interpreter", feature = "bench-pvm"))]
-        Contract::sha1(Default::default()).pvm_runtime,
-    );
-}
-
-criterion_group!(
-    name = prepare;
-    config = Criterion::default();
-    targets = bench_baseline,
-    bench_odd_product,
-    bench_triangle_number,
-    bench_fibonacci_recursive,
-    bench_fibonacci_iterative,
-    bench_fibonacci_binet,
-    bench_sha1
-);
-criterion_main!(prepare);

crates/benchmarks/src/lib.rs

@@ -1,25 +1,70 @@
-use polkavm::{BackendKind, Config, Engine, ExportIndex, Instance, SandboxKind};
+#[cfg(feature = "bench-pvm-interpreter")]
-use revive_integration::mock_runtime::{self, TransactionBuilder};
+pub fn create_specs(contract: &revive_integration::cases::Contract) -> revive_runner::Specs {
-use revive_integration::mock_runtime::{State, Transaction};
+    use revive_runner::*;
-
+    use SpecsAction::*;
-pub fn prepare_pvm(
+    Specs {
-    code: &[u8],
+        differential: false,
-    input: Vec<u8>,
+        actions: vec![
-    backend: BackendKind,
+            Instantiate {
-) -> (TransactionBuilder, Instance<Transaction>, ExportIndex) {
+                code: Code::Bytes(contract.pvm_runtime.to_vec()),
-    let mut config = Config::new();
+                origin: TestAddress::Alice,
-    config.set_backend(Some(backend));
+                data: Default::default(),
-    config.set_sandbox(Some(SandboxKind::Linux));
+                value: Default::default(),
-
+                gas_limit: Default::default(),
-    let (instance, export_index) = mock_runtime::prepare(code, Some(config));
+                storage_deposit_limit: Default::default(),
-    let transaction = State::default().transaction().calldata(input);
+                salt: Default::default(),
-
+            },
-    (transaction, instance, export_index)
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                data: contract.calldata.to_vec(),
+                value: Default::default(),
+                gas_limit: Default::default(),
+                storage_deposit_limit: Default::default(),
+            },
+        ],
+        ..Default::default()
+    }
 }
 
-pub fn instantiate_engine(backend: BackendKind) -> Engine {
+#[cfg(feature = "bench-pvm-interpreter")]
-    let mut config = Config::new();
+pub fn measure_pvm(specs: &revive_runner::Specs, iters: u64) -> std::time::Duration {
-    config.set_backend(Some(backend));
+    use revive_runner::*;
-    config.set_sandbox(Some(SandboxKind::Linux));
+    let mut total_time = std::time::Duration::default();
-    mock_runtime::setup(Some(config))
+
+    for _ in 0..iters {
+        let results = specs.clone().run();
+
+        let CallResult::Exec { result, wall_time } =
+            results.get(1).expect("contract should have been called")
+        else {
+            panic!("expected a execution result");
+        };
+        let ret = result.result.as_ref().unwrap();
+        assert!(!ret.did_revert());
+
+        total_time += *wall_time;
+    }
+
+    total_time
+}
+
+#[cfg(feature = "bench-evm")]
+pub fn measure_evm(code: &[u8], input: &[u8], iters: u64) -> std::time::Duration {
+    let mut total_time = std::time::Duration::default();
+
+    let code = hex::encode(code);
+
+    for _ in 0..iters {
+        let log = revive_differential::Evm::default()
+            .code_blob(code.as_bytes().to_vec())
+            .input(input.to_vec().into())
+            .bench(true)
+            .run();
+        assert!(log.output.run_success(), "evm run failed: {log:?}");
+
+        total_time += log.execution_time().unwrap();
+    }
+
+    total_time
 }

crates/builtins/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "revive-builtins"
-version = "0.1.0"
+version.workspace = true
-edition = "2021"
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
 build = "build.rs"
+description = "compiler builtins for the revive compiler"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+riscv-64 = []
 
 [dependencies]

crates/builtins/build.rs

@@ -1,7 +1,11 @@
 use std::{env, fs, io::Read, path::Path, process::Command};
 
+#[cfg(not(feature = "riscv-64"))]
+pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv32.a";
+#[cfg(feature = "riscv-64")]
+pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
+
 fn main() {
-    let lib = "libclang_rt.builtins-riscv32.a";
     let mut llvm_lib_dir = String::new();
 
     Command::new("llvm-config")
@@ -13,18 +17,24 @@ fn main() {
         .read_to_string(&mut llvm_lib_dir)
         .expect("llvm-config output should be utf8");
 
-    let lib_path = std::path::PathBuf::from(llvm_lib_dir.trim())
+    let mut lib_path = std::path::PathBuf::from(llvm_lib_dir.trim())
         .join("linux")
-        .join(lib);
+        .join(BUILTINS_ARCHIVE_FILE);
-    let archive = fs::read(lib_path).expect("clang builtins for riscv32 not found");
+    if !lib_path.exists() {
+        lib_path = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join(BUILTINS_ARCHIVE_FILE);
+    }
+    let archive = fs::read(lib_path).expect("clang builtins not found");
 
     let out_dir = env::var_os("OUT_DIR").expect("has OUT_DIR");
-    let archive_path = Path::new(&out_dir).join(lib);
+    let archive_path = Path::new(&out_dir).join(BUILTINS_ARCHIVE_FILE);
     let len = archive.len();
     std::fs::write(archive_path, &archive).expect("can write to OUT_DIR");
 
     let src_path = Path::new(&out_dir).join("compiler_rt.rs");
-    let src = format!("pub static COMPILER_RT: &[u8; {len}] = include_bytes!(\"{lib}\");");
+    let src = format!(
+        "pub static COMPILER_RT: &[u8; {len}] = include_bytes!(\"{BUILTINS_ARCHIVE_FILE}\");"
+    );
     fs::write(src_path, src).expect("can write to OUT_DIR");
 
     println!("cargo:rerun-if-changed=build.rs");

crates/common/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,39 +0,0 @@
----
-name: Bug report
-about: Use this template for reporting issues
-title: ''
-labels: bug
-assignees: ''
----
-
-### 🐛 Bug Report
-
-#### 📝 Description
-
-Provide a clear and concise description of the bug.
-
-#### 🔄 Reproduction Steps
-
-Steps to reproduce the behaviour
-
-#### 🤔 Expected Behavior
-
-Describe what you expected to happen.
-
-#### 😯 Current Behavior
-
-Describe what actually happened.
-
-#### 🖥️ Environment
-
-Any relevant environment details.
-
-#### 📋 Additional Context
-
-Add any other context about the problem here. If applicable, add screenshots to help explain.
-
-#### 📎 Log Output
-
-```
-Paste any relevant log output here.
-```

crates/common/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,21 +0,0 @@
----
-name: Feature request
-about: Use this template for requesting features
-title: ''
-labels: feat
-assignees: ''
----
-
-### 🌟 Feature Request
-
-#### 📝 Description
-
-Provide a clear and concise description of the feature you'd like to see.
-
-#### 🤔 Rationale
-
-Explain why this feature is important and how it benefits the project.
-
-#### 📋 Additional Context
-
-Add any other context or information about the feature request here.

crates/common/.github/pull_request_template.md

@@ -1,20 +0,0 @@
-# What ❔
-
-<!-- What are the changes this PR brings about? -->
-<!-- Example: This PR adds a PR template to the repo. -->
-<!-- (For bigger PRs adding more context is appreciated) -->
-
-## Why ❔
-
-<!-- Why are these changes done? What goal do they contribute to? What are the principles behind them? -->
-<!-- Example: PR templates ensure PR reviewers, observers, and future iterators are in context about the evolution of repos. -->
-
-## Checklist
-
-<!-- Check your PR fulfills the following items. -->
-<!-- For draft PRs check the boxes as you complete them. -->
-
-- [ ] PR title corresponds to the body of PR.
-- [ ] Tests for the changes have been added / updated.
-- [ ] Documentation comments have been added / updated.
-- [ ] Code has been formatted via `cargo fmt` and checked with `cargo clippy`.

crates/common/.github/workflows/cargo-license.yaml

@@ -1,9 +0,0 @@
-name: Cargo license check
-on: pull_request
-
-jobs:
-  cargo-deny:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - uses: EmbarkStudios/cargo-deny-action@v1

crates/common/.github/workflows/ci.yaml

@@ -1,23 +0,0 @@
-name: "Rust CI"
-on:
-  pull_request:
-
-jobs:
-  build:
-    name: cargo build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-      - run: cargo build --verbose
-
-  formatting:
-    name: cargo fmt
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          components: rustfmt
-      - name: Rustfmt Check
-        uses: actions-rust-lang/rustfmt@v1

crates/common/.github/workflows/secrets_scanner.yaml

@@ -1,17 +0,0 @@
-name: Leaked Secrets Scan
-on: [pull_request]
-jobs:
-  TruffleHog:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c # v3
-        with:
-          fetch-depth: 0
-      - name: TruffleHog OSS
-        uses: trufflesecurity/trufflehog@0c66d30c1f4075cee1aada2e1ab46dabb1b0071a
-        with:
-          path: ./
-          base: ${{ github.event.repository.default_branch }}
-          head: HEAD
-          extra_args: --debug --only-verified

crates/common/Cargo.toml

@@ -1,17 +1,21 @@
 [package]
 name = "revive-common"
-version = "0.1.0"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
 authors = [
     "Cyrill Leutwiler <cyrill@parity.io>",
     "Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
 ]
-license = "MIT OR Apache-2.0"
-edition = "2021"
 description = "Shared constants of the revive compiler"
 
 [lib]
 doctest = false
 
+[features]
+riscv-64 = []
+
 [dependencies]
 anyhow = { workspace = true }
 serde = { workspace = true, features = ["derive"] }

crates/common/src/bit_length.rs

@@ -20,7 +20,7 @@ pub const BIT_LENGTH_ETH_ADDRESS: usize =
 pub const BIT_LENGTH_WORD: usize = crate::byte_length::BYTE_LENGTH_WORD * BIT_LENGTH_BYTE;
 
 /// Bit length of the runtime value type.
-pub const BIT_LENGTH_VALUE: usize = crate::byte_length::BYTE_LENGTH_VALUE * BIT_LENGTH_BYTE;
+pub const BIT_LENGTH_VALUE: usize = BIT_LENGTH_WORD;
 
 /// Bit length of thre runimte block number type.
 pub const BIT_LENGTH_BLOCK_NUMBER: usize =

crates/common/src/byte_length.rs

@@ -6,12 +6,12 @@ pub const BYTE_LENGTH_BYTE: usize = 1;
 /// The x86 word byte-length.
 pub const BYTE_LENGTH_X32: usize = 4;
 
-/// Native stack alignment size in bytes
-pub const BYTE_LENGTH_STACK_ALIGN: usize = 4;
-
 /// The x86_64 word byte-length.
 pub const BYTE_LENGTH_X64: usize = 8;
 
+/// EVM native stack alignment size in bytes
+pub const BYTE_LENGTH_STACK_ALIGN: usize = 32;
+
 /// The ETH address byte-length.
 pub const BYTE_LENGTH_ETH_ADDRESS: usize = 20;
 
@@ -22,7 +22,7 @@ pub const BYTE_LENGTH_WORD: usize = 32;
 pub const BYTE_LENGTH_VALUE: usize = 32;
 
 /// Byte length of the runtime block number type.
-pub const BYTE_LENGTH_BLOCK_NUMBER: usize = 8;
+pub const BYTE_LENGTH_BLOCK_NUMBER: usize = 4;
 
 /// Byte length of the runtime block timestamp type.
-pub const BYTE_LENGTH_BLOCK_TIMESTAMP: usize = 8;
+pub const BYTE_LENGTH_BLOCK_TIMESTAMP: usize = 4;

crates/common/src/exit_code.rs

@@ -1,6 +1,4 @@
-//!
+//! The revive exit code constants.
-//! The exit code constants.
-//!
 
 /// The common application success exit code.
 pub const EXIT_CODE_SUCCESS: i32 = 0;

crates/common/src/extension.rs

@@ -30,9 +30,6 @@ pub static EXTENSION_SOLIDITY: &str = "sol";
 /// The LLL IR file extension.
 pub static EXTENSION_LLL: &str = "lll";
 
-/// The Vyper file extension.
-pub static EXTENSION_VYPER: &str = "vy";
-
 /// The LLVM source code file extension.
 pub static EXTENSION_LLVM_SOURCE: &str = "ll";
 

crates/common/src/lib.rs

@@ -6,7 +6,6 @@ pub(crate) mod byte_length;
 pub(crate) mod evm_version;
 pub(crate) mod exit_code;
 pub(crate) mod extension;
-pub(crate) mod polkavm;
 pub(crate) mod utils;
 
 pub use self::base::*;
@@ -15,5 +14,4 @@ pub use self::byte_length::*;
 pub use self::evm_version::EVMVersion;
 pub use self::exit_code::*;
 pub use self::extension::*;
-pub use self::polkavm::address::*;
 pub use self::utils::*;

crates/common/src/polkavm/address.rs

@@ -1,115 +0,0 @@
-//! The PolkaVM address constants.
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_TO_L1: u16 = 0xFFFF;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_PRECOMPILE: u16 = 0xFFFD;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_META: u16 = 0xFFFC;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_MIMIC_CALL: u16 = 0xFFFB;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_SYSTEM_MIMIC_CALL: u16 = 0xFFFA;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_MIMIC_CALL_BYREF: u16 = 0xFFF9;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_SYSTEM_MIMIC_CALL_BYREF: u16 = 0xFFF8;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_RAW_FAR_CALL: u16 = 0xFFF7;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_RAW_FAR_CALL_BYREF: u16 = 0xFFF6;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_SYSTEM_CALL: u16 = 0xFFF5;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_SYSTEM_CALL_BYREF: u16 = 0xFFF4;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_SET_CONTEXT_VALUE_CALL: u16 = 0xFFF3;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_SET_PUBDATA_PRICE: u16 = 0xFFF2;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_INCREMENT_TX_COUNTER: u16 = 0xFFF1;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_GET_GLOBAL_PTR_CALLDATA: u16 = 0xFFF0;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_GET_GLOBAL_CALL_FLAGS: u16 = 0xFFEF;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_GET_GLOBAL_PTR_RETURN_DATA: u16 = 0xFFEE;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_EVENT_INITIALIZE: u16 = 0xFFED;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_EVENT_WRITE: u16 = 0xFFEC;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_LOAD_CALLDATA: u16 = 0xFFEB;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_LOAD_RETURN_DATA: u16 = 0xFFEA;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_ADD: u16 = 0xFFE9;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_SHRINK: u16 = 0xFFE8;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_PACK: u16 = 0xFFE7;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_MULTIPLICATION_HIGH_REGISTER: u16 = 0xFFE6;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_GET_GLOBAL_EXTRA_ABI_DATA: u16 = 0xFFE5;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_DATA_LOAD: u16 = 0xFFE4;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_DATA_COPY: u16 = 0xFFE3;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_DATA_SIZE: u16 = 0xFFE2;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_CONST_ARRAY_DECLARE: u16 = 0xFFE1;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_CONST_ARRAY_SET: u16 = 0xFFE0;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_CONST_ARRAY_FINALIZE: u16 = 0xFFDF;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_CONST_ARRAY_GET: u16 = 0xFFDE;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_DECOMMIT: u16 = 0xFFDD;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_LOAD_DECOMMIT: u16 = 0xFFDC;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_RETURN_FORWARD: u16 = 0xFFDB;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_REVERT_FORWARD: u16 = 0xFFDA;
-
-/// The corresponding simulation predefined address.
-pub const POLKAVM_ADDRESS_ACTIVE_PTR_SWAP: u16 = 0xFFD9;

crates/common/src/polkavm/mod.rs

@@ -1,5 +0,0 @@
-//!
-//! The PolkaVM constants.
-//!
-
-pub mod address;

crates/differential/Cargo.toml

@@ -1,11 +1,16 @@
 [package]
 name = "revive-differential"
-version = "0.1.0"
+version.workspace = true
-edition = "2021"
+license.workspace = true
-
+edition.workspace = true
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+authors.workspace = true
+repository.workspace = true
 
 [dependencies]
-evm-interpreter = { workspace = true }
+hex = { workspace = true }
-primitive-types = { workspace = true }
+tempfile = { workspace = true }
-alloy-primitives = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+alloy-primitives = { workspace = true, features = ["serde"] }
+alloy-genesis = { workspace = true }
+alloy-serde = { workspace = true }

crates/differential/genesis.json

@@ -0,0 +1,40 @@
+{
+    "config": {
+        "chainId": 420420420,
+        "homesteadBlock": 0,
+        "eip150Block": 0,
+        "eip155Block": 0,
+        "eip158Block": 0,
+        "byzantiumBlock": 0,
+        "constantinopleBlock": 0,
+        "petersburgBlock": 0,
+        "istanbulBlock": 0,
+        "berlinBlock": 0,
+        "londonBlock": 0,
+        "arrowGlacierBlock": 0,
+        "grayGlacierBlock": 0,
+        "shanghaiTime": 0,
+        "cancunTime": 0,
+        "terminalTotalDifficulty": 0,
+        "terminalTotalDifficultyPassed": true
+    },
+    "coinbase": "0x0000000000000000000000000000000000000000",
+    "difficulty": "0x20000",
+    "extraData": "",
+    "gasLimit": "0xffffffff",
+    "nonce": "0x0000000000000042",
+    "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "timestamp": "0x00",
+    "alloc": {
+        "0101010101010101010101010101010101010101": {
+            "balance": "1000000000"
+        },
+        "0202020202020202020202020202020202020202": {
+            "balance": "1000000000"
+        },
+        "0303030303030303030303030303030303030303": {
+            "balance": "1000000000"
+        }
+    }
+}

crates/differential/src/go_duration.rs

@@ -0,0 +1,199 @@
+use std::time::Duration;
+
+/// Parse a go formatted duration.
+///
+/// Sources:
+/// - https://crates.io/crates/go-parse-duration (fixed an utf8 bug)
+/// - https://github.com/golang/go/blob/master/src/time/format.go
+pub fn parse_go_duration(value: &str) -> Result<Duration, String> {
+    parse_duration(value).map(|ns| Duration::from_nanos(ns.unsigned_abs()))
+}
+
+fn parse_duration(string: &str) -> Result<i64, String> {
+    // [-+]?([0-9]*(\.[0-9]*)?[a-z]+)+
+    let mut s = string;
+    let mut d: i64 = 0; // duration to be returned
+    let mut neg = false;
+
+    // Consume [-+]?
+    if !s.is_empty() {
+        let c = *s.as_bytes().first().unwrap();
+        if c == b'-' || c == b'+' {
+            neg = c == b'-';
+            s = &s[1..];
+        }
+    }
+    // Special case: if all that is left is "0", this is zero.
+    if s == "0" {
+        return Ok(0);
+    }
+    if s.is_empty() {
+        return Err(format!("invalid duration: {string}"));
+    }
+    while !s.is_empty() {
+        // integers before, after decimal point
+        let mut v: i64;
+        let mut f: i64 = 0;
+        // value = v + f / scale
+        let mut scale: f64 = 1f64;
+
+        // The next character must be [0-9.]
+        let c = *s.as_bytes().first().unwrap();
+        if !(c == b'.' || c.is_ascii_digit()) {
+            return Err(format!("invalid duration: {string}"));
+        }
+        // Consume [0-9]*
+        let pl = s.len();
+        match leading_int(s) {
+            Ok((_v, _s)) => {
+                v = _v;
+                s = _s;
+            }
+            Err(_) => {
+                return Err(format!("invalid duration: {string}"));
+            }
+        }
+        let pre = pl != s.len(); // whether we consume anything before a period
+
+        // Consume (\.[0-9]*)?
+        let mut post = false;
+        if !s.is_empty() && *s.as_bytes().first().unwrap() == b'.' {
+            s = &s[1..];
+            let pl = s.len();
+            let (f_, scale_, s_) = leading_fraction(s);
+            {
+                f = f_;
+                scale = scale_;
+                s = s_;
+            }
+            post = pl != s.len();
+        }
+        if !pre && !post {
+            // no digits (e.g. ".s" or "-.s")
+            return Err(format!("invalid duration: {string}"));
+        }
+
+        // Consume unit.
+        let mut i = 0;
+        while i < s.len() {
+            let c = *s.as_bytes().get(i).unwrap();
+            if c == b'.' || c.is_ascii_digit() {
+                break;
+            }
+            i += 1;
+        }
+        if i == 0 {
+            return Err(format!("missing unit in duration: {string}"));
+        }
+        let u = &s[..i];
+        s = &s[i..];
+        let unit = match u {
+            "ns" => 1i64,
+            "us" => 1000i64,
+            "µs" => 1000i64, // U+00B5 = micro symbol
+            "μs" => 1000i64, // U+03BC = Greek letter mu
+            "ms" => 1000000i64,
+            "s" => 1000000000i64,
+            "m" => 60000000000i64,
+            "h" => 3600000000000i64,
+            _ => {
+                return Err(format!("unknown unit {u} in duration {string}"));
+            }
+        };
+        if v > (1 << (63 - 1)) / unit {
+            // overflow
+            return Err(format!("invalid duration {string}"));
+        }
+        v *= unit;
+        if f > 0 {
+            // f64 is needed to be nanosecond accurate for fractions of hours.
+            // v >= 0 && (f*unit/scale) <= 3.6e+12 (ns/h, h is the largest unit)
+            v += (f as f64 * (unit as f64 / scale)) as i64;
+            if v < 0 {
+                // overflow
+                return Err(format!("invalid duration {string}"));
+            }
+        }
+        d += v;
+        if d < 0 {
+            // overflow
+            return Err(format!("invalid duration {string}"));
+        }
+    }
+    if neg {
+        d = -d;
+    }
+    Ok(d)
+}
+
+fn leading_int(s: &str) -> Result<(i64, &str), String> {
+    let mut x = 0;
+    let mut i = 0;
+    while i < s.len() {
+        let c = s.chars().nth(i).unwrap();
+        if !c.is_ascii_digit() {
+            break;
+        }
+        if x > (1 << (63 - 1)) / 10 {
+            return Err("overflow".into());
+        }
+        let d = i64::from(c.to_digit(10).unwrap());
+        x = x * 10 + d;
+        if x < 0 {
+            // overflow
+            return Err("overflow".into());
+        }
+        i += 1;
+    }
+    Ok((x, &s[i..]))
+}
+
+fn leading_fraction(s: &str) -> (i64, f64, &str) {
+    let mut i = 0;
+    let mut x = 0i64;
+    let mut scale = 1f64;
+    let mut overflow = false;
+    while i < s.len() {
+        let c = s.chars().nth(i).unwrap();
+        if !c.is_ascii_digit() {
+            break;
+        }
+        if overflow {
+            continue;
+        }
+        if x > (1 << (63 - 1)) / 10 {
+            // It's possible for overflow to give a positive number, so take care.
+            overflow = true;
+            continue;
+        }
+        let d = i64::from(c.to_digit(10).unwrap());
+        let y = x * 10 + d;
+        if y < 0 {
+            overflow = true;
+            continue;
+        }
+        x = y;
+        scale *= 10f64;
+        i += 1;
+    }
+    (x, scale, &s[i..])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_duration;
+
+    #[test]
+    fn test_parse_duration() {
+        assert_eq!(parse_duration("8.731µs"), Ok(8731));
+        assert_eq!(parse_duration("50ns"), Ok(50));
+        assert_eq!(parse_duration("3ms"), Ok(3000000));
+        assert_eq!(parse_duration("2us"), Ok(2000));
+        assert_eq!(parse_duration("4.0s"), Ok(4000000000));
+        assert_eq!(parse_duration("1h45m"), Ok(6300000000000));
+        assert_eq!(
+            parse_duration("1"),
+            Err(String::from("missing unit in duration: 1")),
+        );
+    }
+}

crates/differential/src/lib.rs

@@ -1,159 +1,569 @@
-use alloy_primitives::{keccak256, Address, B256};
+use core::str;
-use evm_interpreter::{
+use std::{
-    interpreter::{EtableInterpreter, RunInterpreter},
+    collections::BTreeMap,
-    trap::CallCreateTrap,
+    io::Write,
-    Context, Etable, ExitError, Log, Machine, RuntimeBackend, RuntimeBaseBackend,
+    path::PathBuf,
-    RuntimeEnvironment, RuntimeState, TransactionContext, Valids,
+    process::{Command, Stdio},
+    str::FromStr,
+    time::Duration,
 };
-use primitive_types::{H160, H256, U256};
 
-static RUNTIME_ETABLE: Etable<RuntimeState, UnimplementedHandler, CallCreateTrap> =
+use alloy_genesis::{Genesis, GenesisAccount};
-    Etable::runtime();
+use alloy_primitives::{hex::ToHexExt, Address, Bytes, B256, U256};
+use alloy_serde::storage::deserialize_storage_map;
+use serde::{Deserialize, Serialize};
+use serde_json::{Deserializer, Value};
+use tempfile::{NamedTempFile, TempPath};
 
-#[derive(Default)]
+pub use self::go_duration::parse_go_duration;
-pub struct UnimplementedHandler {
+
-    logs: Vec<Log>,
+mod go_duration;
+
+const GENESIS_JSON: &str = include_str!("../genesis.json");
+const EXECUTABLE_NAME: &str = "evm";
+const EXECUTABLE_ARGS: [&str; 8] = [
+    "--log.format=json",
+    "run",
+    "--dump",
+    "--nomemory=false",
+    "--noreturndata=false",
+    "--json",
+    "--codefile",
+    "-",
+];
+const EXECUTABLE_ARGS_BENCH: [&str; 6] = [
+    "run",
+    "--bench",
+    "--nomemory=false",
+    "--noreturndata=false",
+    "--codefile",
+    "-",
+];
+const GAS_USED_MARKER: &str = "EVM gas used:";
+const REVERT_MARKER: &str = " error: ";
+
+/// The geth EVM state dump structure
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct StateDump {
+    pub root: Bytes,
+    pub accounts: BTreeMap<Address, Account>,
 }
 
-impl RuntimeEnvironment for UnimplementedHandler {
+impl From<StateDump> for Genesis {
-    fn block_hash(&self, _number: U256) -> H256 {
+    fn from(value: StateDump) -> Self {
-        unimplemented!()
+        let mut genesis: Genesis = serde_json::from_str(GENESIS_JSON).unwrap();
-    }
+        genesis.alloc = value
-    fn block_number(&self) -> U256 {
+            .accounts
-        U256::from(123)
+            .iter()
-    }
+            .map(|(address, account)| (*address, account.clone().into()))
-    fn block_coinbase(&self) -> H160 {
+            .collect();
-        unimplemented!()
+        genesis
-    }
-    fn block_timestamp(&self) -> U256 {
-        U256::from(456)
-    }
-    fn block_difficulty(&self) -> U256 {
-        unimplemented!()
-    }
-    fn block_randomness(&self) -> Option<H256> {
-        unimplemented!()
-    }
-    fn block_gas_limit(&self) -> U256 {
-        unimplemented!()
-    }
-    fn block_base_fee_per_gas(&self) -> U256 {
-        unimplemented!()
-    }
-    fn chain_id(&self) -> U256 {
-        unimplemented!()
     }
 }
 
-impl RuntimeBaseBackend for UnimplementedHandler {
+/// The geth EVM state dump account structure
-    fn balance(&self, _address: H160) -> U256 {
+#[derive(Clone, Debug, Serialize, Deserialize)]
-        unimplemented!()
+pub struct Account {
-    }
+    pub balance: U256,
-    fn code_size(&self, _address: H160) -> U256 {
+    pub nonce: u64,
-        unimplemented!()
+    pub code: Option<Bytes>,
-    }
+    #[serde(
-    fn code_hash(&self, _address: H160) -> H256 {
+        default,
-        unimplemented!()
+        skip_serializing_if = "Option::is_none",
-    }
+        deserialize_with = "deserialize_storage_map"
-    fn code(&self, _address: H160) -> Vec<u8> {
+    )]
-        unimplemented!()
+    pub storage: Option<BTreeMap<B256, B256>>,
-    }
+    pub key: Option<B256>,
-    fn storage(&self, _address: H160, _index: H256) -> H256 {
+}
-        unimplemented!()
-    }
 
-    fn exists(&self, _address: H160) -> bool {
+impl From<Account> for GenesisAccount {
-        unimplemented!()
+    fn from(value: Account) -> Self {
+        GenesisAccount {
+            balance: value.balance,
+            nonce: Some(value.nonce),
+            code: value.code,
+            storage: value.storage,
+            private_key: value.key,
         }
-
-    fn nonce(&self, _address: H160) -> U256 {
-        unimplemented!()
     }
 }
 
-impl RuntimeBackend for UnimplementedHandler {
+/// Contains the output from geth `emv` invocations
-    fn original_storage(&self, _address: H160, _index: H256) -> H256 {
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-        unimplemented!()
+pub struct EvmOutput {
-    }
+    pub output: Bytes,
+    #[serde(rename = "gasUsed")]
+    pub gas_used: U256,
+    pub error: Option<String>,
+}
 
-    fn deleted(&self, _address: H160) -> bool {
+impl EvmOutput {
-        unimplemented!()
+    /// Return if there was no error found.
-    }
+    ///
-    fn is_cold(&self, _address: H160, _index: Option<H256>) -> bool {
+    /// Panics if the gas used is zero as this indicates nothing was run.
-        unimplemented!()
+    pub fn run_success(&self) -> bool {
-    }
+        assert_ne!(self.gas_used, U256::ZERO, "nothing was executed: {self:?}");
-
+        self.error.is_none()
-    fn mark_hot(&mut self, _address: H160, _index: Option<H256>) {
-        unimplemented!()
-    }
-
-    fn set_storage(&mut self, _address: H160, _index: H256, _value: H256) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-    fn log(&mut self, log: Log) -> Result<(), ExitError> {
-        self.logs.push(log);
-        Ok(())
-    }
-    fn mark_delete(&mut self, _address: H160) {
-        unimplemented!()
-    }
-
-    fn reset_storage(&mut self, _address: H160) {
-        unimplemented!()
-    }
-
-    fn set_code(&mut self, _address: H160, _code: Vec<u8>) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-    fn reset_balance(&mut self, _address: H160) {
-        unimplemented!()
-    }
-
-    fn deposit(&mut self, _address: H160, _value: U256) {
-        unimplemented!()
-    }
-    fn withdrawal(&mut self, _address: H160, _value: U256) -> Result<(), ExitError> {
-        unimplemented!()
-    }
-
-    fn inc_nonce(&mut self, _address: H160) -> Result<(), ExitError> {
-        unimplemented!()
     }
 }
 
-#[derive(Clone)]
+/// Contains the full log from geth `emv` invocations
-pub struct PreparedEvm {
+#[derive(Clone, Debug)]
-    pub valids: Valids,
+pub struct EvmLog {
-    pub vm: Machine<RuntimeState>,
+    pub account_deployed: Option<Address>,
+    pub output: EvmOutput,
+    pub state_dump: StateDump,
+    pub stderr: String,
 }
 
-pub fn prepare(code: Vec<u8>, data: Vec<u8>) -> PreparedEvm {
+impl EvmLog {
-    let address = Address::default().create2(B256::default(), keccak256([]).0);
+    pub const EXECUTION_TIME_MARKER: &'static str = "execution time:";
-    let caller = Address::default().create2(B256::default(), keccak256([]).0);
 
-    let state = RuntimeState {
+    /// Parse the reported execution time from stderr (requires --bench)
-        context: Context {
+    pub fn execution_time(&self) -> Result<Duration, String> {
-            address: H160::from(address.0 .0),
+        for line in self.stderr.lines() {
-            caller: H160::from(caller.0 .0),
+            if let Some(value) = line.split("execution time:").nth(1) {
-            apparent_value: U256::default(),
+                return parse_go_duration(value.trim());
+            }
+        }
+
+        Err(format!(
+            "execution time marker '{}' not found in raw EVM log",
+            Self::EXECUTION_TIME_MARKER
+        ))
+    }
+
+    fn parse_gas_used_from_bench(&mut self) {
+        for line in self.stderr.lines() {
+            if let Some(gas_line) = line.split(GAS_USED_MARKER).nth(1) {
+                let gas_used = gas_line.trim().parse::<u64>().unwrap_or_else(|error| {
+                    panic!("invalid output '{gas_line}' for gas used: {error}")
+                });
+                self.output.gas_used = U256::from(gas_used);
+            }
+        }
+    }
+}
+
+impl From<&str> for EvmLog {
+    fn from(value: &str) -> Self {
+        let mut output = None;
+        let mut state_dump = None;
+        for value in Deserializer::from_str(value).into_iter::<Value>() {
+            let Ok(value) = value else { continue };
+            if let Ok(value @ EvmOutput { .. }) = serde_json::from_value(value.clone()) {
+                output = Some(value);
+                continue;
+            }
+            if let Ok(value @ StateDump { .. }) = serde_json::from_value(value) {
+                state_dump = Some(value);
+            }
+        }
+
+        if let (Some(output), Some(state_dump)) = (output, state_dump) {
+            return Self {
+                account_deployed: None,
+                output,
+                state_dump,
+                stderr: value.into(),
+            };
+        }
+
+        EvmLog {
+            account_deployed: None,
+            output: EvmOutput {
+                error: value.find(REVERT_MARKER).map(|_| REVERT_MARKER.to_string()),
+                ..Default::default()
             },
-        transaction_context: TransactionContext {
+            state_dump: Default::default(),
-            gas_price: U256::default(),
+            stderr: Default::default(),
-            origin: H160::default(),
         }
-        .into(),
+    }
-        retbuf: Vec::new(),
+}
+
+/// Builder for running contracts in geth `evm`
+pub struct Evm {
+    genesis_json: Option<String>,
+    genesis_path: Option<PathBuf>,
+    code: Option<Vec<u8>>,
+    input: Option<Bytes>,
+    receiver: Option<String>,
+    sender: String,
+    value: Option<u128>,
+    gas: Option<u64>,
+    create: bool,
+    bench: bool,
+}
+
+impl Default for Evm {
+    fn default() -> Self {
+        Self {
+            genesis_json: Some(GENESIS_JSON.to_string()),
+            genesis_path: None,
+            code: None,
+            input: None,
+            receiver: None,
+            sender: Address::default().encode_hex(),
+            value: None,
+            gas: None,
+            create: false,
+            bench: false,
+        }
+    }
+}
+
+impl Evm {
+    /// Create a new EVM with the given `genesis`
+    pub fn from_genesis(genesis: Genesis) -> Self {
+        Self::default().genesis_json(genesis)
+    }
+
+    /// Run the `code`
+    pub fn code_blob(self, blob: Vec<u8>) -> Self {
+        Self {
+            code: Some(blob),
+            ..self
+        }
+    }
+
+    /// Set the calldata
+    pub fn input(self, bytes: Bytes) -> Self {
+        Self {
+            input: (!bytes.is_empty()).then_some(bytes),
+            ..self
+        }
+    }
+
+    /// Set the create flag
+    pub fn deploy(self, enable: bool) -> Self {
+        Self {
+            create: enable,
+            ..self
+        }
+    }
+
+    /// Set the transferred value
+    pub fn value(self, value: u128) -> Self {
+        Self {
+            value: Some(value),
+            ..self
+        }
+    }
+
+    /// Set the gas limit
+    pub fn gas(self, limit: u64) -> Self {
+        Self {
+            gas: Some(limit),
+            ..self
+        }
+    }
+
+    /// Provide the prestate genesis configuration
+    pub fn genesis_json(self, genesis: Genesis) -> Self {
+        let genesis_json = serde_json::to_string(&genesis).expect("state dump should be valid");
+        // TODO: Investigate
+        let genesis_json = genesis_json.replace("\"0x0\"", "0").into();
+
+        Self {
+            genesis_json,
+            genesis_path: None,
+            ..self
+        }
+    }
+
+    /// Provide a path to the genesis file to be used
+    pub fn genesis_path(self, path: PathBuf) -> Self {
+        Self {
+            genesis_path: Some(path),
+            genesis_json: None,
+            ..self
+        }
+    }
+
+    /// Set the callee address
+    pub fn receiver(self, address: Address) -> Self {
+        Self {
+            receiver: Some(address.encode_hex()),
+            ..self
+        }
+    }
+
+    /// Set the caller address
+    pub fn sender(self, address: Address) -> Self {
+        Self {
+            sender: address.encode_hex(),
+            ..self
+        }
+    }
+
+    /// Run as a benchmark
+    pub fn bench(self, flag: bool) -> Self {
+        Self {
+            bench: flag,
+            ..self
+        }
+    }
+
+    /// Calculate the address of the contract account this deploy call would create
+    pub fn expect_account_created(&self) -> Address {
+        assert!(self.create, "expected a deploy call");
+        let sender = Address::from_str(&self.sender).expect("sender address should be valid");
+        let genesis: Genesis = match (self.genesis_json.as_ref(), self.genesis_path.as_ref()) {
+            (Some(json), None) => serde_json::from_str(json).unwrap(),
+            (None, Some(path)) => {
+                serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap()
+            }
+            _ => panic!("provided a genesis json and a genesis json path"),
+        };
+        let nonce = genesis
+            .alloc
+            .get(&sender)
+            .map(|account| account.nonce.unwrap_or(0))
+            .unwrap_or(0);
+        sender.create(nonce)
+    }
+
+    /// Return the path to the genesis file;
+    /// writes the genesis file into a tmpdir if necessary.
+    ///
+    /// `TempPath`` will delete on drop, so need to keep it around
+    fn write_genesis_file(&self, temp_path: &mut Option<TempPath>) -> String {
+        match (self.genesis_json.as_ref(), self.genesis_path.as_ref()) {
+            (Some(json), None) => {
+                let mut temp_file = NamedTempFile::new().unwrap();
+                temp_file.write_all(json.as_bytes()).unwrap();
+                let path = temp_file.into_temp_path();
+                *temp_path = Some(path);
+                temp_path.as_ref().unwrap().display().to_string()
+            }
+            (None, Some(path)) => path.display().to_string(),
+            _ => panic!("provided a genesis json and a genesis json path"),
+        }
+    }
+
+    /// Run the call in a geth `evm` subprocess.
+    ///
+    /// Definitively not a hairy plumbing function.
+    pub fn run(self) -> EvmLog {
+        let mut temp_path = None;
+        let genesis_json_path = &self.write_genesis_file(&mut temp_path);
+
+        // Static args
+        let mut command = Command::new(PathBuf::from(EXECUTABLE_NAME));
+        command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped());
+        if self.bench {
+            command.args(EXECUTABLE_ARGS_BENCH);
+        } else {
+            command.args(EXECUTABLE_ARGS);
         };
 
-    PreparedEvm {
+        // Dynamic args
-        valids: Valids::new(&code[..]),
+        command.args(["--prestate", genesis_json_path]);
-        vm: evm_interpreter::Machine::new(code.into(), data.to_vec().into(), 1024, 0xFFFF, state),
+        command.args(["--sender", &self.sender]);
+        if let Some(input) = &self.input {
+            command.args(["--input", hex::encode(input).as_str()]);
+        }
+        let account_deployed = if self.create {
+            command.arg("--create");
+            self.expect_account_created().into()
+        } else {
+            None
+        };
+        match (&self.code, &self.receiver) {
+            (Some(_), None) => {}
+            (None, Some(address)) => {
+                command.args(["--receiver", address]);
+            }
+            (Some(_), Some(_)) => panic!("code and receiver specified"),
+            _ => panic!("no code file or receiver specified"),
+        }
+        if let Some(gas) = self.gas {
+            command.args(["--gas", &format!("{gas}")]);
+        }
+        if let Some(value) = self.value {
+            command.args(["--value", &format!("{value}")]);
+        }
+
+        // Run the evm subprocess and assert success return value
+        let process = command.spawn().unwrap_or_else(|error| {
+            panic!("{EXECUTABLE_NAME} subprocess spawning error: {error:?}")
+        });
+        let buf = vec![];
+        process
+            .stdin
+            .as_ref()
+            .unwrap_or_else(|| panic!("{EXECUTABLE_NAME} stdin getting error"))
+            .write_all(self.code.as_ref().unwrap_or(&buf))
+            .unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} stdin writing error: {err:?}"));
+
+        let output = process
+            .wait_with_output()
+            .unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} subprocess output error: {err}"));
+        assert!(
+            output.status.success(),
+            "{EXECUTABLE_NAME} command failed: {output:?}",
+        );
+        drop(temp_path);
+
+        let stdout = str::from_utf8(output.stdout.as_slice())
+            .unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} stdout failed to parse: {err}"));
+        let stderr = str::from_utf8(output.stderr.as_slice())
+            .unwrap_or_else(|err| panic!("{EXECUTABLE_NAME} stderr failed to parse: {err}"));
+
+        let mut log: EvmLog = stdout.into();
+        log.stderr = stderr.into();
+        if self.bench {
+            log.parse_gas_used_from_bench();
+        }
+
+        // Set the deployed account
+        log.account_deployed = account_deployed;
+        log
     }
 }
 
-pub fn execute(pre: PreparedEvm) -> (Vec<u8>, Vec<Log>) {
+#[cfg(test)]
-    let mut vm = EtableInterpreter::new_valid(pre.vm, &RUNTIME_ETABLE, pre.valids);
+mod tests {
-    let mut handler = UnimplementedHandler::default();
+    use std::{str::FromStr, time::Duration};
-    vm.run(&mut handler).exit().unwrap().unwrap();
+
-    (vm.retval.clone(), handler.logs)
+    use alloy_genesis::Genesis;
+    use alloy_primitives::{Bytes, B256, U256};
+
+    use crate::{Evm, EvmLog, EvmOutput, StateDump};
+
+    const OUTPUT_JSON_OK: &str = r#"{"output":"0000000000000000000000000000000000000000000000000000000000000000","gasUsed":"0x11d"}"#;
+    const OUTPUT_JSON_REVERTED: &str =
+        r#"{"output":"","gasUsed":"0x2d","error":"execution reverted"}"#;
+    const STATE_DUMP: &str = r#"
+{
+    "root": "eb5d51177cb9049b848ea92f87f9a3f00abfb683d0866c2eddecc5692ad27f86",
+    "accounts": {
+        "0x1f2a98889594024BFfdA3311CbE69728d392C06D": {
+            "balance": "0",
+            "nonce": 1,
+            "root": "0x63cfcda8d81a8b1840b1b9722c37f929a4037e53ad1ce6abdef31c0c8bac1f61",
+            "codeHash": "0xa6e0062c5ba829446695f179b97702a75f7d354e33445d2e928ed00e1a39e88f",
+            "code": "0x608060405260043610610028575f3560e01c80633fa4f2451461002c578063b144adfb1461004a575b5f80fd5b610034610086565b60405161004191906100c5565b60405180910390f35b348015610055575f80fd5b50610070600480360381019061006b919061013c565b61008d565b60405161007d91906100c5565b60405180910390f35b5f34905090565b5f8173ffffffffffffffffffffffffffffffffffffffff16319050919050565b5f819050919050565b6100bf816100ad565b82525050565b5f6020820190506100d85f8301846100b6565b92915050565b5f80fd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f61010b826100e2565b9050919050565b61011b81610101565b8114610125575f80fd5b50565b5f8135905061013681610112565b92915050565b5f60208284031215610151576101506100de565b5b5f61015e84828501610128565b9150509291505056fea2646970667358221220a2109c2f05a629fff4640e9f0cf12a698bbea9b0858a4029901e88bf5d1c926964736f6c63430008190033",
+            "storage": {
+                "0x0000000000000000000000000000000000000000000000000000000000000000": "02"
+            },
+            "address": "0x1f2a98889594024bffda3311cbe69728d392c06d",
+            "key": "0xcbeeb4463624bc2f332dcfe2b479eddb1c380ec862ee63d9f31b31b854fb7c61"
+        }
+    }
+}"#;
+    const EVM_BIN_FIXTURE: &str = "6080604052348015600e575f80fd5b506040516101403803806101408339818101604052810190602e9190607f565b805f806101000a81548160ff0219169083151502179055505060a5565b5f80fd5b5f8115159050919050565b606181604f565b8114606a575f80fd5b50565b5f81519050607981605a565b92915050565b5f602082840312156091576090604b565b5b5f609c84828501606d565b91505092915050565b608f806100b15f395ff3fe6080604052348015600e575f80fd5b50600436106026575f3560e01c8063cde4efa914602a575b5f80fd5b60306032565b005b5f8054906101000a900460ff16155f806101000a81548160ff02191690831515021790555056fea264697066735822122046c92dd2fd612b1ed93d184dad4c49f61c44690722c4a6c7c746ebeb0aadeb4a64736f6c63430008190033";
+    const EVM_BIN_RUNTIME_FIXTURE: &str = "6080604052348015600e575f80fd5b50600436106026575f3560e01c8063cde4efa914602a575b5f80fd5b60306032565b005b5f8054906101000a900460ff16155f806101000a81548160ff02191690831515021790555056fea264697066735822122046c92dd2fd612b1ed93d184dad4c49f61c44690722c4a6c7c746ebeb0aadeb4a64736f6c63430008190033";
+    const EVM_BIN_FIXTURE_INPUT: &str =
+        "0000000000000000000000000000000000000000000000000000000000000001";
+    const EVM_BIN_RUNTIME_FIXTURE_INPUT: &str = "cde4efa9";
+    const STDERR_BENCH_OK: &str = r#"EVM gas used:    560071
+execution time:  1.460881ms
+allocations:     29
+allocated bytes: 2558
+"#;
+    const STDERR_BENCH_REVERT: &str = r#"EVM gas used:    69
+execution time:  10.11µs
+allocations:     43
+allocated bytes: 3711"#;
+    const STDOUT_BENCH_REVERT: &str = r#" error: execution reverted"#;
+
+    #[test]
+    fn parse_evm_output_ok() {
+        serde_json::from_str::<EvmOutput>(OUTPUT_JSON_OK).unwrap();
+    }
+
+    #[test]
+    fn parse_evm_output_revert() {
+        serde_json::from_str::<EvmOutput>(OUTPUT_JSON_REVERTED).unwrap();
+    }
+
+    #[test]
+    fn parse_evm_output_bench_ok() {
+        let mut log = EvmLog::from("");
+        log.stderr = STDERR_BENCH_OK.into();
+        log.parse_gas_used_from_bench();
+        assert!(log.output.run_success());
+
+        assert_eq!(log.execution_time().unwrap(), Duration::from_nanos(1460881));
+    }
+
+    #[test]
+    fn parse_evm_output_bench_revert() {
+        let mut log = EvmLog::from(STDOUT_BENCH_REVERT);
+        log.stderr = STDERR_BENCH_REVERT.into();
+        log.parse_gas_used_from_bench();
+        assert!(!log.output.run_success());
+    }
+
+    #[test]
+    fn parse_state_dump() {
+        serde_json::from_str::<StateDump>(STATE_DUMP).unwrap();
+    }
+
+    #[test]
+    fn evm_log_from_str() {
+        let log = format!("{OUTPUT_JSON_OK}\n{STATE_DUMP}");
+        let _ = EvmLog::from(log.as_str());
+    }
+
+    #[test]
+    fn generate_genesis() {
+        let log = format!("{OUTPUT_JSON_OK}\n{STATE_DUMP}");
+        let log = EvmLog::from(log.as_str());
+        let mut genesis: Genesis = log.state_dump.into();
+        let storage = genesis
+            .alloc
+            .pop_first()
+            .expect("should have one account in genesis")
+            .1
+            .storage
+            .expect("genesis account should have storage");
+        let storage_value = storage
+            .get(&B256::ZERO)
+            .expect("genesis account should have key 0 occupied");
+        assert_eq!(*storage_value, B256::from(U256::from(2)));
+    }
+
+    #[test]
+    fn flipper() {
+        let log_runtime = Evm::default()
+            .code_blob(EVM_BIN_RUNTIME_FIXTURE.as_bytes().to_vec())
+            .input(Bytes::from_str(EVM_BIN_RUNTIME_FIXTURE_INPUT).unwrap())
+            .run();
+        assert!(log_runtime.output.run_success());
+    }
+
+    #[test]
+    fn prestate() {
+        let log_deploy = Evm::default()
+            .code_blob(EVM_BIN_FIXTURE.as_bytes().to_vec())
+            .input(Bytes::from_str(EVM_BIN_FIXTURE_INPUT).unwrap())
+            .deploy(true)
+            .run();
+        assert!(log_deploy.output.run_success());
+
+        let address = log_deploy.account_deployed.unwrap();
+        let genesis: Genesis = log_deploy.state_dump.into();
+        let log_runtime = Evm::default()
+            .genesis_json(genesis)
+            .receiver(address)
+            .input(Bytes::from_str(EVM_BIN_RUNTIME_FIXTURE_INPUT).unwrap())
+            .run();
+        assert!(log_runtime.output.run_success(), "{:?}", log_runtime.output);
+    }
+
+    #[test]
+    fn bench_flipper() {
+        let log_runtime = Evm::default()
+            .code_blob(EVM_BIN_RUNTIME_FIXTURE.as_bytes().to_vec())
+            .input(Bytes::from_str(EVM_BIN_RUNTIME_FIXTURE_INPUT).unwrap())
+            .bench(true)
+            .run();
+        assert!(log_runtime.output.run_success());
+        assert!(log_runtime.execution_time().unwrap() > Duration::from_nanos(0));
+    }
 }

crates/extensions/Cargo.toml

@@ -1,9 +0,0 @@
-[package]
-name = "revive-extensions"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-0"] }

crates/extensions/bswap.ll

@@ -1,13 +0,0 @@
-target datalayout = "e-m:e-p:32:32-i64:64-n32-S128"
-target triple = "riscv32-unknown-unknown-elf"
-
-define dso_local noundef i256 @__bswap(i256 noundef %0) local_unnamed_addr #0 {
-  %2 = tail call i256 @llvm.bswap.i256(i256 %0)
-  ret i256 %2
-}
-
-; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i256 @llvm.bswap.i256(i256) #1
-
-attributes #0 = { alwaysinline mustprogress nofree norecurse nosync nounwind willreturn memory(none) }
-attributes #1 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }

crates/extensions/build.rs

@@ -1,40 +0,0 @@
-use std::{env, fs, path::Path, process::Command};
-
-fn compile(source_path: &str, output_path: &str) {
-    let output = Command::new("llc")
-        .args([
-            "-O3",
-            "-filetype=asm",
-            "-mattr=+zbb,+e",
-            source_path,
-            "-o",
-            output_path,
-        ])
-        .output()
-        .expect("should be able to invoke llc");
-
-    assert!(
-        output.status.success(),
-        "failed to compile {}: {:?}",
-        source_path,
-        output
-    );
-}
-
-fn main() {
-    let in_file = "bswap.ll";
-    let out_file = "bswap.s";
-    let out_dir = env::var_os("OUT_DIR").expect("env should have $OUT_DIR");
-    let out_path = Path::new(&out_dir).join(out_file);
-    compile(
-        in_file,
-        out_path.to_str().expect("$OUT_DIR should be UTF-8"),
-    );
-
-    let src_path = Path::new(&out_dir).join("bswap.rs");
-    let src = format!("pub static ASSEMBLY: &str = include_str!(\"{out_file}\");");
-    fs::write(src_path, src).expect("should be able to write in $OUT_DIR");
-
-    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-changed=bswap.ll");
-}

crates/extensions/src/lib.rs

@@ -1,39 +0,0 @@
-//! Custom RISC-V extension in PolkaVM that are partially supported.
-//! We use inline assembly to emit partially supported instructions.
-
-use inkwell::{context::Context, module::Module, support::LLVMString};
-
-include!(concat!(env!("OUT_DIR"), "/bswap.rs"));
-
-/// Returns a LLVM module containing a `__bswap` function, which
-/// - Takes a `i256` value argument
-/// - Byte swaps it using `rev8` from the `zbb` extension
-/// - Returns the `i256` value
-/// Returns `Error` if the module fails to validate, which should never happen.
-pub fn module<'context>(
-    context: &'context Context,
-    module_name: &str,
-) -> Result<Module<'context>, LLVMString> {
-    let module = context.create_module(module_name);
-
-    module.set_inline_assembly(ASSEMBLY);
-    module.verify()?;
-
-    Ok(module)
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn assembly_contains_rev8_instruction() {
-        assert!(crate::ASSEMBLY.contains("rev8"));
-    }
-
-    #[test]
-    fn module_is_valid() {
-        inkwell::targets::Target::initialize_riscv(&Default::default());
-        let context = inkwell::context::Context::create();
-
-        assert!(crate::module(&context, "polkavm_bswap").is_ok());
-    }
-}

crates/integration/Cargo.toml

@@ -1,9 +1,11 @@
 [package]
 name = "revive-integration"
-version = "0.1.0"
+version.workspace = true
-edition = "2021"
+license.workspace = true
-
+edition.workspace = true
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+repository.workspace = true
+authors.workspace = true
+description = "revive compiler integration test cases"
 
 [dependencies]
 polkavm = { workspace = true }
@@ -11,11 +13,14 @@ alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 hex = { workspace = true }
 env_logger = { workspace = true }
+log = { workspace = true }
+serde_json = { workspace = true }
 
-revive-solidity = { path = "../solidity" }
+revive-solidity = { workspace = true }
-revive-differential = { path = "../differential" }
+revive-differential = { workspace = true }
-revive-llvm-context = { path = "../llvm-context" }
+revive-llvm-context = { workspace = true }
-revive-common = { path = "../common" }
+revive-common = { workspace = true }
+revive-runner = { workspace = true }
 
 [dev-dependencies]
 sha1 = { workspace = true }

crates/integration/codesize.json

@@ -1,10 +1,10 @@
 {
-  "Baseline": 3944,
+  "Baseline": 989,
-  "Computation": 7444,
+  "Computation": 4153,
-  "DivisionArithmetics": 42784,
+  "DivisionArithmetics": 40614,
-  "ERC20": 56199,
+  "ERC20": 47343,
-  "Events": 4784,
+  "Events": 1781,
-  "FibonacciIterative": 6019,
+  "FibonacciIterative": 3035,
-  "Flipper": 4392,
+  "Flipper": 3393,
-  "SHA1": 36107
+  "SHA1": 33553
 }

crates/integration/contracts/Baseline.sol

@@ -1,5 +1,20 @@
 // SPDX-License-Identifier: MIT
 
+/* runner.json
+
+{
+  "actions": [
+    {
+      "Instantiate": {
+        "origin": "Alice",
+        "value": 0
+      }
+    }
+  ]
+}
+
+*/
+
 pragma solidity ^0.8;
 
 contract Baseline {

crates/integration/contracts/Bitwise.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Bitwise"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "3fa4f245"
+            }
+        }
+    ]
+}
+*/
+
+contract Bitwise {
+    function opByte(uint i, uint x) public payable returns (uint ret) {
+        assembly {
+            ret := byte(i, x)
+        }
+    }
+}

crates/integration/contracts/Block.sol

@@ -2,12 +2,49 @@
 
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Block"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "8381f58a"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b80777ea"
+            }
+        }
+    ]
+}
+*/
+
 contract Block {
     function timestamp() public view returns (uint ret) {
         ret = block.timestamp;
     }
 
     function number() public view returns (uint ret) {
+        if (block.number == 0) {
+            ret = 1;
+        } else {
             ret = block.number;
         }
+    }
 }

crates/integration/contracts/Call.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Callee"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Caller"
+                    }
+                },
+                "value": 123
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "5a6535fc00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000004cafebabe00000000000000000000000000000000000000000000000000000000"
+            }
+        }
+    ]
+}
+*/
+
+contract Callee {
+    function echo(bytes memory payload) public pure returns (bytes memory) {
+        return payload;
+    }
+
+    receive() external payable {}
+}
+
+contract Caller {
+    constructor() payable {
+        Callee callee = new Callee();
+        payable(address(callee)).transfer(msg.value);
+    }
+
+    function call(bytes memory payload) public returns (bytes memory) {
+        Callee callee = new Callee();
+        return callee.echo(payload);
+    }
+}

crates/integration/contracts/Computation.sol

@@ -2,6 +2,44 @@
 
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "actions": [
+    {
+      "Instantiate": {}
+    },
+    {
+      "Call": {
+        "dest": {
+            "Instantiated": 0
+        },
+        "data": "0f760610000000000000000000000000000000000000000000000000000000000000000d"
+      }
+    },
+    {
+        "VerifyCall": {
+            "success": true,
+            "output": "000000000000000000000000000000000000000000000000000000000000005b"
+        }
+    },
+    {
+      "Call": {
+        "dest": {
+            "Instantiated": 0
+        },
+        "data": "00261b660000000000000000000000000000000000000000000000000000000000000005"
+      }
+    },
+    {
+        "VerifyCall": {
+            "success": true,
+            "output": "00000000000000000000000000000000000000000000000000000000000003b1"
+        }
+    }
+  ]
+}
+*/
+
 contract Computation {
     function triangle_number(int64 n) public pure returns (int64 sum) {
         unchecked {

crates/integration/contracts/Context.sol

@@ -2,6 +2,47 @@
 
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Context"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "846a1ee1"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "fc9c8d39"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "3af973b1"
+            }
+        }
+    ]
+}
+*/
+
 contract Context {
     function address_this() public view returns (address ret) {
         ret = address(this);
@@ -10,4 +51,12 @@ contract Context {
     function caller() public view returns (address ret) {
         ret = msg.sender;
     }
+
+    function chain_id() public view returns (uint) {
+        uint256 id;
+        assembly {
+            id := chainid()
+        }
+        return id;
+    }
 }

crates/integration/contracts/Create.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "CreateA"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "CreateB"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "value": 10000
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                }
+            }
+        }
+    ]
+}
+*/
+
+contract CreateA {
+    constructor() payable {}
+}
+
+contract CreateB {
+    receive() external payable {
+        new CreateA{value: msg.value}();
+    }
+
+    fallback() external {
+        new CreateA{salt: hex"01"}();
+    }
+}

crates/integration/contracts/Crypto.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+/* runner.json
+{
+  "differential": true,
+  "actions": [
+    {
+      "Instantiate": {
+        "code": {
+          "Solidity": {
+            "contract": "TestSha3"
+          }
+        }
+      }
+    },
+    {
+      "Call": {
+        "dest": {
+          "Instantiated": 0
+        },
+        "data": "f9fbd5540000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000c68656c6c6f20776f726c64210000000000000000000000000000000000000000"
+      }
+    }
+  ]
+}
+*/
+
+contract TestSha3 {
+    function test(string memory _pre) external payable returns (bytes32) {
+        bytes32 hash = keccak256(bytes(_pre));
+        return bytes32(uint(hash) + 1);
+    }
+}

crates/integration/contracts/ERC20.sol

@@ -2,6 +2,16 @@
 
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "actions": [
+    {
+      "Instantiate": {}
+    }
+  ]
+}
+*/
+
 // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.0.0/contracts/token/ERC20/IERC20.sol
 interface IERC20 {
     function totalSupply() external view returns (uint);

crates/integration/contracts/Events.sol

@@ -2,6 +2,39 @@
 
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Events"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "4d43bec90000000000000000000000000000000000000000000000000000000000000000"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "4d43bec9000000000000000000000000000000000000000000000000000000000000007b"
+            }
+        }
+    ]
+}
+*/
+
 contract Events {
     event A() anonymous;
     event E(uint, uint indexed, uint indexed, uint indexed);

crates/integration/contracts/ExtCode.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+contract ExtCode {
+    function ExtCodeSize(address who) public view returns (uint ret) {
+        assembly {
+            ret := extcodesize(who)
+        }
+    }
+
+    function CodeSize() public pure returns (uint ret) {
+        assembly {
+            ret := codesize()
+        }
+    }
+
+    function ExtCodeHash(address who) public view returns (bytes32 ret) {
+        assembly {
+            ret := extcodehash(who)
+        }
+    }
+
+    function CodeHash() public view returns (bytes32 ret) {
+        assembly {
+            ret := extcodehash(address())
+        }
+    }
+}

crates/integration/contracts/Fibonacci.sol

@@ -2,7 +2,29 @@
 
 pragma solidity ^0.8;
 
-// https://medium.com/coinmonks/fibonacci-in-solidity-8477d907e22a
+/* runner.json
+{
+    "actions": [
+    {
+      "Instantiate": {}
+    },
+    {
+      "Call": {
+        "dest": {
+            "Instantiated": 0
+        },
+        "data": "6b83dd2e0000000000000000000000000000000000000000000000000000000000000006"
+      }
+    },
+    {
+        "VerifyCall": {
+            "success": true,
+            "output": "0000000000000000000000000000000000000000000000000000000000000008"
+        }
+    }
+  ]
+}
+*/
 
 contract FibonacciRecursive {
     function f(uint n) internal pure returns (uint) {
@@ -36,6 +58,7 @@ contract FibonacciIterative {
     }
 }
 
+// https://medium.com/coinmonks/fibonacci-in-solidity-8477d907e22a
 contract FibonacciBinet {
     function fib3(uint n) external pure returns (uint a) {
         if (n == 0) {

crates/integration/contracts/Immutables.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+/* runner.json
+{
+  "differential": true,
+  "actions": [
+    {
+      "Upload": {
+        "code": {
+          "Solidity": {
+            "contract": "ImmutablesTester"
+          }
+        }
+      }
+    },
+    {
+      "Instantiate": {
+        "code": {
+          "Solidity": {
+            "contract": "Immutables"
+          }
+        }
+      }
+    },
+    {
+      "Call": {
+        "dest": {
+          "Instantiated": 0
+        }
+      }
+    }
+  ]
+}
+*/
+
+contract ImmutablesTester {
+    // Read should work in the runtime code
+    uint public immutable foo;
+    // Read should work in the runtime code
+    uint public immutable bar;
+    // Read should work in the runtime code
+    uint public immutable zoo;
+
+    // Assign and read should work in the constructor
+    constructor(uint _foo) payable {
+        foo = _foo;
+        bar = foo + 1;
+        zoo = bar + 2;
+
+        assert(zoo == _foo + 3);
+    }
+}
+
+contract Immutables {
+    fallback() external {
+        ImmutablesTester tester = new ImmutablesTester(127);
+
+        assert(tester.foo() == 127);
+        assert(tester.bar() == tester.foo() + 1);
+        assert(tester.zoo() == tester.bar() + 2);
+    }
+}

crates/integration/contracts/MCopy.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "MCopy"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "0ee188b0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000030102030000000000000000000000000000000000000000000000000000000000"
+            }
+        }
+    ]
+}
+*/
+
+contract MCopy {
+    function memcpy(bytes memory payload) public pure returns (bytes memory) {
+        return payload;
+    }
+}

crates/integration/contracts/MSize.sol

@@ -2,6 +2,40 @@
 
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+    {
+        "Instantiate": {
+            "code": {
+                "Solidity": {
+                    "contract": "MSize",
+                    "solc_optimizer": false
+                }
+            }
+        }
+    },
+    {
+        "Call": {
+            "dest": {
+                "Instantiated": 0
+            },
+            "data": "f016832c"
+        }
+    },
+    {
+        "Call": {
+            "dest": {
+                "Instantiated": 0
+            },
+            "data": "f4a63aa5"
+        }
+    }
+  ]
+}
+*/
+
 contract MSize {
     uint[] public data;
 

crates/integration/contracts/MStore8.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "MStore8"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad4210000000000000000000000000000000000000000000000000000000000000000"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad4210000000000000000000000000000000000000000000000000000000000000001"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad4210000000000000000000000000000000000000000000000000000000000000002"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad42100000000000000000000000000000000000000000000000000000000000000ff"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad4210000000000000000000000000000000000000000000000000000000000000100"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad4210000000000000000000000000000000000000000000000000000000000000101"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad4210000000000000000000000000000000000000000000000000000000000000102"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad42100000000000000000000000000000000000000000000000000000000075bcd15"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "b09ad421ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+            }
+        }
+    ]
+}
+*/
+
+contract MStore8 {
+    function mStore8(uint value) public pure returns (uint256 word) {
+        assembly {
+            mstore8(0x80, value)
+            word := mload(0x80)
+        }
+    }
+}

crates/integration/contracts/ReturnDataOob.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Callee"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "ReturnDataOob"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                }
+            }
+        }
+    ]
+}
+*/
+
+contract Callee {
+    function echo(bytes memory payload) public pure returns (bytes memory) {
+        return payload;
+    }
+}
+
+contract ReturnDataOob {
+    fallback() external {
+        new Callee().echo(hex"1234");
+        assembly {
+            let pos := mload(64)
+            let size := add(returndatasize(), 1)
+            returndatacopy(pos, 0, size)
+        }
+    }
+}

crates/integration/contracts/SHA1.sol

@@ -1,6 +1,31 @@
 // SPDX-License-Identifier: BSD-2-Clause
 pragma solidity ^0.8.4;
 
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "SHA1"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "1605782b00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000200ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+            }
+        }
+    ]
+}
+*/
+
 contract SHA1 {
     function sha1(bytes memory data) public pure returns (bytes20 ret) {
         assembly {

crates/integration/contracts/Storage.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Storage"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "fabc9efaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+            }
+        }
+    ]
+}
+*/
+
+contract Storage {
+    function transient(uint value) public returns (uint ret) {
+        assembly {
+            let slot := 123
+            tstore(slot, value)
+            let success := call(0, 0, 0, 0, 0, 0, 0)
+            ret := tload(slot)
+        }
+    }
+}

crates/integration/contracts/Transfer.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "Transfer"
+                    }
+                },
+                "value": 11
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "1c8d16b30000000000000000000000000303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000a"
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "fb9e8d0500000000000000000000000003030303030303030303030303030303030303030000000000000000000000000000000000000000000000000000000000000001"
+            }
+        }
+    ]
+}
+*/
+
+contract Transfer {
+    constructor() payable {
+        transfer_self(msg.value);
+    }
+
+    function address_self() internal view returns (address payable) {
+        return payable(address(this));
+    }
+
+    function transfer_self(uint _amount) public payable {
+        transfer_to(address_self(), _amount);
+    }
+
+    function transfer_to(address payable _dest, uint _amount) public payable {
+        _dest.transfer(_amount);
+    }
+}

crates/integration/contracts/Value.sol

@@ -1,8 +1,65 @@
 // SPDX-License-Identifier: MIT
-
 pragma solidity ^0.8;
 
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "ValueTester"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "value": 1024,
+                "code": {
+                    "Solidity": {
+                        "contract": "Value"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "value": 123,
+                "data": "3fa4f245"
+            }
+        }
+    ]
+}
+*/
+
+contract ValueTester {
+    constructor() payable {}
+
+    function balance_self() public view returns (uint ret) {
+        ret = address(this).balance;
+    }
+}
+
 contract Value {
+    constructor() payable {
+        ValueTester tester = new ValueTester{value: msg.value}();
+
+        // own account
+        assert(address(this).balance == 0);
+
+        // tester account
+        assert(address(tester).balance == msg.value);
+        assert(tester.balance_self() == msg.value);
+
+        // non-existant account
+        assert(address(0xdeadbeef).balance == 0);
+    }
+
     function value() public payable returns (uint ret) {
         ret = msg.value;
     }

crates/integration/contracts/flipper.sol

@@ -1,9 +1,51 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 
+/* runner.json
+{
+  "actions": [
+    {
+      "Instantiate": {
+        "data": "0000000000000000000000000000000000000000000000000000000000000001"
+      }
+    },
+    {
+        "VerifyStorage": {
+            "contract": {
+                "Instantiated": 0
+            },
+            "key": "0000000000000000000000000000000000000000000000000000000000000000",
+            "expected": "0100000000000000000000000000000000000000000000000000000000000000"
+        }
+    },
+    {
+      "Call": {
+        "dest": {
+            "Instantiated": 0
+        },
+        "data": "cde4efa9"
+      }
+    },
+    {
+        "VerifyStorage": {
+            "contract": {
+                "Instantiated": 0
+            },
+            "key": "0000000000000000000000000000000000000000000000000000000000000000",
+            "expected": "0000000000000000000000000000000000000000000000000000000000000000"
+        }
+    }
+  ]
+}
+*/
+
 contract Flipper {
     bool coin;
 
+    constructor(bool _coin) {
+        coin = _coin;
+    }
+
     function flip() public {
         coin = !coin;
     }

crates/integration/contracts/mStore8.sol

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8;
-
-contract MStore8 {
-    function mStore8(uint value) public pure returns (uint256 word) {
-        assembly {
-            mstore8(0x80, value)
-            word := mload(0x80)
-        }
-    }
-}

crates/integration/src/cases.rs

@@ -1,7 +1,7 @@
-use alloy_primitives::{I256, U256};
+use alloy_primitives::{Address, Bytes, I256, U256};
-use alloy_sol_types::{sol, SolCall};
+use alloy_sol_types::{sol, SolCall, SolConstructor};
 
-use crate::mock_runtime::{CallOutput, State};
+use revive_solidity::test_utils::*;
 
 #[derive(Clone)]
 pub struct Contract {
@@ -11,41 +11,90 @@ pub struct Contract {
     pub calldata: Vec<u8>,
 }
 
-sol!(contract Baseline { function baseline() public payable; });
+macro_rules! case {
+    // Arguments:
+    //     1. The file name, expect to live under "../contracts/"
+    //     2. The Solidity contract name
+    //     3. The derived Solidity function call name
+    //     4. The method name on [Contract]
+    //     5. Any parameters to the Solidity functions
+    ($file_name:literal, $contract_name:ident, $contract_method:ident, $method_name:ident, $( $v:ident: $t:ty ),* ) => {
+        impl Contract {
+            pub fn $method_name($($v: $t),*) -> Self {
+                let code = include_str!(concat!("../contracts/", $file_name));
+                let args = $contract_name::$contract_method::new(($($v,)*)).abi_encode();
+                let name = stringify!($contract_name);
+                Contract::build(args, name, code)
+            }
+        }
+    };
 
-sol!(contract Flipper { function flip() public; });
+    // Arguments:
+    //     1. The file name, expect to live under "../contracts/"
+    //     2. The Solidity contract name
+    //     3. Raw Calldata
+    //     4. The method name on [Contract]
+    ($file_name:literal, $contract_name:literal, $calldata:expr, $method_name:ident) => {
+        impl Contract {
+            pub fn $method_name() -> Self {
+                let code = include_str!(concat!("../contracts/", $file_name));
+                Contract::build($calldata, $contract_name, code)
+            }
+        }
+    };
+}
+
+case!("Create.sol", "CreateA", vec![0; 4], create_a);
+case!("Create.sol", "CreateB", vec![0; 4], create_b);
+
+sol!(contract Baseline { function baseline() public payable; });
+case!("Baseline.sol", Baseline, baselineCall, baseline,);
+
+sol!(contract Flipper {
+    constructor (bool);
+
+    function flip() public;
+});
+case!("flipper.sol", Flipper, flipCall, flipper,);
+case!("flipper.sol", Flipper, constructorCall, flipper_constructor, coin: bool);
 
 sol!(contract Computation {
     function odd_product(int32 n) public pure returns (int64);
     function triangle_number(int64 n) public pure returns (int64 sum);
 });
+case!("Computation.sol", Computation, odd_productCall, odd_product, n: i32);
+case!("Computation.sol", Computation, triangle_numberCall, triangle_number, n: i64);
 
 sol!(
     contract FibonacciRecursive {
         function fib3(uint n) public pure returns (uint);
     }
 );
+case!("Fibonacci.sol", FibonacciRecursive, fib3Call, fib_recursive, n: U256);
 
 sol!(
     contract FibonacciIterative {
         function fib3(uint n) external pure returns (uint b);
     }
 );
+case!("Fibonacci.sol", FibonacciIterative, fib3Call, fib_iterative, n: U256);
 
 sol!(
     contract FibonacciBinet {
         function fib3(uint n) external pure returns (uint a);
     }
 );
+case!("Fibonacci.sol", FibonacciBinet, fib3Call, fib_binet, n: U256);
 
 sol!(
     contract SHA1 {
         function sha1(bytes memory data) public pure returns (bytes20 ret);
     }
 );
+case!("SHA1.sol", SHA1, sha1Call, sha1, pre: Bytes);
 
 sol!(
-    interface IERC20 {
+    contract ERC20 {
         function totalSupply() external view returns (uint);
 
         function balanceOf(address account) external view returns (uint);
@@ -69,6 +118,7 @@ sol!(
         event Approval(address indexed owner, address indexed spender, uint value);
     }
 );
+case!("ERC20.sol", ERC20, totalSupplyCall, erc20,);
 
 sol!(
     contract Block {
@@ -77,6 +127,8 @@ sol!(
         function number() public view returns (uint ret);
     }
 );
+case!("Block.sol", Block, numberCall, block_number,);
+case!("Block.sol", Block, timestampCall, block_timestamp,);
 
 sol!(
     contract Context {
@@ -85,6 +137,8 @@ sol!(
         function caller() public pure returns (address);
     }
 );
+case!("Context.sol", Context, address_thisCall, context_address,);
+case!("Context.sol", Context, callerCall, context_caller,);
 
 sol!(
     contract DivisionArithmetics {
@@ -97,12 +151,17 @@ sol!(
         function smod(int n, int d) public pure returns (int r);
     }
 );
+case!("DivisionArithmetics.sol", DivisionArithmetics, divCall, division_arithmetics_div, n: U256, d: U256);
+case!("DivisionArithmetics.sol", DivisionArithmetics, sdivCall, division_arithmetics_sdiv, n: I256, d: I256);
+case!("DivisionArithmetics.sol", DivisionArithmetics, modCall, division_arithmetics_mod, n: U256, d: U256);
+case!("DivisionArithmetics.sol", DivisionArithmetics, smodCall, division_arithmetics_smod, n: I256, d: I256);
 
 sol!(
     contract MStore8 {
         function mStore8(uint value) public pure returns (uint256 word);
     }
 );
+case!("MStore8.sol", MStore8, mStore8Call, mstore8, value: U256);
 
 sol!(
     contract Events {
@@ -112,258 +171,84 @@ sol!(
         function emitEvent(uint topics) public;
     }
 );
+case!("Events.sol", Events, emitEventCall, event, topics: U256);
+
+sol!(
+    contract ExtCode {
+        function ExtCodeSize(address who) public view returns (uint ret);
+
+        function CodeSize() public pure returns (uint ret);
+
+        function ExtCodeHash(address who) public view returns (bytes32 ret);
+
+        function CodeHash() public view returns (bytes32 ret);
+    }
+);
+case!("ExtCode.sol", ExtCode, ExtCodeSizeCall, ext_code_size, address: Address);
+case!("ExtCode.sol", ExtCode, CodeSizeCall, code_size,);
+case!("ExtCode.sol", ExtCode, ExtCodeHashCall, ext_code_hash, address: Address);
+case!("ExtCode.sol", ExtCode, CodeHashCall, code_hash,);
+
+sol!(
+    contract MCopy {
+        function memcpy(bytes memory payload) public pure returns (bytes memory);
+    }
+);
+case!("MCopy.sol", MCopy, memcpyCall, memcpy, payload: Bytes);
+
+sol!(
+    contract Call {
+        function value_transfer(address payable destination) public payable;
+
+        function echo(bytes memory payload) public payable returns (bytes memory);
+
+        function call(
+            address callee,
+            bytes memory payload
+        ) public payable returns (bytes memory);
+    }
+);
+case!("Call.sol", Call, value_transferCall, call_value_transfer, destination: Address);
+case!("Call.sol", Call, callCall, call_call, destination: Address, payload: Bytes);
+case!("Call.sol", "Call", vec![], call_constructor);
+
+sol!(
+    contract Value {
+        function balance_of(address _address) public view returns (uint ret);
+        function balance_self() public view returns (uint ret);
+    }
+);
+case!("Value.sol", Value, balance_ofCall, value_balance_of, address: Address);
+case!("Value.sol", Value, balance_selfCall, value_balance_self,);
+
+sol!(
+    contract Bitwise {
+        function opByte(uint i, uint x) public payable returns (uint ret);
+    }
+);
+case!("Bitwise.sol", Bitwise, opByteCall, bitwise_byte, index: U256, value: U256);
+
+sol!(
+    contract Storage {
+        function transient(uint value) public returns (uint ret);
+    }
+);
+case!("Storage.sol", Storage, transientCall, storage_transient, value: U256);
 
 impl Contract {
-    /// Execute the contract.
+    fn build(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
-    ///
-    /// Useful helper if the contract state can be ignored,
-    /// as it spares the deploy transaciton.
-    ///
-    /// - Inserts an account with given `code` into a new state.
-    /// - Callee and caller account will be `Transaction::default_address()`.
-    /// - Sets the calldata.
-    /// - Doesn't execute the constructor or deploy code.
-    /// - Calls the "call" export on a default backend config.
-    pub fn execute(&self) -> (State, CallOutput) {
-        State::default()
-            .transaction()
-            .with_default_account(&self.pvm_runtime)
-            .calldata(self.calldata.clone())
-            .call()
-    }
-
-    pub fn baseline() -> Self {
-        let code = include_str!("../contracts/Baseline.sol");
-        let name = "Baseline";
-
         Self {
             name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
+            evm_runtime: compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
+            pvm_runtime: compile_blob(name, code),
-            calldata: Baseline::baselineCall::new(()).abi_encode(),
+            calldata,
-        }
-    }
-
-    pub fn odd_product(n: i32) -> Self {
-        let code = include_str!("../contracts/Computation.sol");
-        let name = "Computation";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Computation::odd_productCall::new((n,)).abi_encode(),
-        }
-    }
-
-    pub fn triangle_number(n: i64) -> Self {
-        let code = include_str!("../contracts/Computation.sol");
-        let name = "Computation";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Computation::triangle_numberCall::new((n,)).abi_encode(),
-        }
-    }
-
-    pub fn fib_recursive(n: u32) -> Self {
-        let code = include_str!("../contracts/Fibonacci.sol");
-        let name = "FibonacciRecursive";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: FibonacciRecursive::fib3Call::new((U256::from(n),)).abi_encode(),
-        }
-    }
-
-    pub fn fib_iterative(n: u32) -> Self {
-        let code = include_str!("../contracts/Fibonacci.sol");
-        let name = "FibonacciIterative";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: FibonacciIterative::fib3Call::new((U256::from(n),)).abi_encode(),
-        }
-    }
-
-    pub fn fib_binet(n: u32) -> Self {
-        let code = include_str!("../contracts/Fibonacci.sol");
-        let name = "FibonacciBinet";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: FibonacciBinet::fib3Call::new((U256::from(n),)).abi_encode(),
-        }
-    }
-
-    pub fn sha1(pre: Vec<u8>) -> Self {
-        let code = include_str!("../contracts/SHA1.sol");
-        let name = "SHA1";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: SHA1::sha1Call::new((pre,)).abi_encode(),
-        }
-    }
-
-    pub fn flipper() -> Self {
-        let code = include_str!("../contracts/flipper.sol");
-        let name = "Flipper";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Flipper::flipCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn erc20() -> Self {
-        let code = include_str!("../contracts/ERC20.sol");
-        let name = "ERC20";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: IERC20::totalSupplyCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn block_number() -> Self {
-        let code = include_str!("../contracts/Block.sol");
-        let name = "Block";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Block::numberCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn block_timestamp() -> Self {
-        let code = include_str!("../contracts/Block.sol");
-        let name = "Block";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Block::timestampCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn context_address() -> Self {
-        let code = include_str!("../contracts/Context.sol");
-        let name = "Context";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Context::address_thisCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn context_caller() -> Self {
-        let code = include_str!("../contracts/Context.sol");
-        let name = "Context";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Context::callerCall::new(()).abi_encode(),
-        }
-    }
-
-    pub fn division_arithmetics_div(n: U256, d: U256) -> Self {
-        let code = include_str!("../contracts/DivisionArithmetics.sol");
-        let name = "DivisionArithmetics";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: DivisionArithmetics::divCall::new((n, d)).abi_encode(),
-        }
-    }
-
-    pub fn division_arithmetics_sdiv(n: I256, d: I256) -> Self {
-        let code = include_str!("../contracts/DivisionArithmetics.sol");
-        let name = "DivisionArithmetics";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: DivisionArithmetics::sdivCall::new((n, d)).abi_encode(),
-        }
-    }
-
-    pub fn division_arithmetics_mod(n: U256, d: U256) -> Self {
-        let code = include_str!("../contracts/DivisionArithmetics.sol");
-        let name = "DivisionArithmetics";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: DivisionArithmetics::modCall::new((n, d)).abi_encode(),
-        }
-    }
-
-    pub fn division_arithmetics_smod(n: I256, d: I256) -> Self {
-        let code = include_str!("../contracts/DivisionArithmetics.sol");
-        let name = "DivisionArithmetics";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: DivisionArithmetics::smodCall::new((n, d)).abi_encode(),
-        }
-    }
-
-    pub fn mstore8(value: U256) -> Self {
-        let code = include_str!("../contracts/mStore8.sol");
-        let name = "MStore8";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: MStore8::mStore8Call::new((value,)).abi_encode(),
-        }
-    }
-
-    pub fn event(topics: U256) -> Self {
-        let code = include_str!("../contracts/Events.sol");
-        let name = "Events";
-
-        Self {
-            name,
-            evm_runtime: crate::compile_evm_bin_runtime(name, code),
-            pvm_runtime: crate::compile_blob(name, code),
-            calldata: Events::emitEventCall::new((topics,)).abi_encode(),
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use alloy_primitives::U256;
+    use alloy_primitives::{Bytes, U256};
     use rayon::iter::{IntoParallelIterator, ParallelIterator};
     use serde::{de::Deserialize, Serialize};
     use std::{collections::BTreeMap, fs::File};
@@ -406,9 +291,9 @@ mod tests {
             Contract::baseline as fn() -> Contract,
             Contract::flipper as fn() -> Contract,
             (|| Contract::odd_product(0)) as fn() -> Contract,
-            (|| Contract::fib_iterative(0)) as fn() -> Contract,
+            (|| Contract::fib_iterative(U256::ZERO)) as fn() -> Contract,
             Contract::erc20 as fn() -> Contract,
-            (|| Contract::sha1(Vec::new())) as fn() -> Contract,
+            (|| Contract::sha1(Bytes::new())) as fn() -> Contract,
             (|| Contract::division_arithmetics_div(U256::ZERO, U256::ZERO)) as fn() -> Contract,
             (|| Contract::event(U256::ZERO)) as fn() -> Contract,
         ]

crates/integration/src/lib.rs

@@ -1,108 +1,4 @@
-use alloy_primitives::{Address, U256};
-use cases::Contract;
-use mock_runtime::{CallOutput, State};
-
-use crate::mock_runtime::{Event, ReturnFlags};
-
 pub mod cases;
-pub mod mock_runtime;
 
 #[cfg(test)]
 mod tests;
-
-/// Compile the blob of `contract_name` found in given `source_code`.
-/// The `solc` optimizer will be enabled
-pub fn compile_blob(contract_name: &str, source_code: &str) -> Vec<u8> {
-    compile_blob_with_options(
-        contract_name,
-        source_code,
-        true,
-        revive_solidity::SolcPipeline::Yul,
-    )
-}
-
-/// Compile the EVM bin-runtime of `contract_name` found in given `source_code`.
-/// The `solc` optimizer will be enabled
-pub fn compile_evm_bin_runtime(contract_name: &str, source_code: &str) -> Vec<u8> {
-    let file_name = "contract.sol";
-
-    let contracts = revive_solidity::test_utils::build_solidity_with_options_evm(
-        [(file_name.into(), source_code.into())].into(),
-        Default::default(),
-        None,
-        revive_solidity::SolcPipeline::Yul,
-        true,
-    )
-    .expect("source should compile");
-    let bin_runtime = &contracts
-        .get(contract_name)
-        .unwrap_or_else(|| panic!("contract '{}' didn't produce bin-runtime", contract_name))
-        .object;
-
-    hex::decode(bin_runtime).expect("bin-runtime shold be hex encoded")
-}
-
-/// Compile the blob of `contract_name` found in given `source_code`.
-pub fn compile_blob_with_options(
-    contract_name: &str,
-    source_code: &str,
-    solc_optimizer_enabled: bool,
-    pipeline: revive_solidity::SolcPipeline,
-) -> Vec<u8> {
-    let file_name = "contract.sol";
-
-    let contracts = revive_solidity::test_utils::build_solidity_with_options(
-        [(file_name.into(), source_code.into())].into(),
-        Default::default(),
-        None,
-        pipeline,
-        revive_llvm_context::OptimizerSettings::cycles(),
-        solc_optimizer_enabled,
-    )
-    .expect("source should compile")
-    .contracts
-    .expect("source should contain at least one contract");
-
-    let bytecode = contracts[file_name][contract_name]
-        .evm
-        .as_ref()
-        .expect("source should produce EVM output")
-        .bytecode
-        .as_ref()
-        .expect("source should produce assembly text")
-        .object
-        .as_str();
-
-    hex::decode(bytecode).expect("hex encoding should always be valid")
-}
-
-pub fn assert_success(contract: &Contract, differential: bool) -> (State, CallOutput) {
-    let (state, output) = contract.execute();
-    assert_eq!(output.flags, ReturnFlags::Success);
-
-    if differential {
-        let evm =
-            revive_differential::prepare(contract.evm_runtime.clone(), contract.calldata.clone());
-        let (evm_output, evm_log) = revive_differential::execute(evm);
-
-        assert_eq!(output.data.clone(), evm_output);
-        assert_eq!(output.events.len(), evm_log.len());
-        assert_eq!(
-            output.events,
-            evm_log
-                .iter()
-                .map(|log| Event {
-                    address: Address::from_slice(log.address.as_bytes()),
-                    data: log.data.clone(),
-                    topics: log
-                        .topics
-                        .iter()
-                        .map(|topic| U256::from_be_bytes(topic.0))
-                        .collect(),
-                })
-                .collect::<Vec<_>>()
-        );
-    }
-
-    (state, output)
-}

crates/integration/src/mock_runtime.rs

@@ -1,662 +0,0 @@
-//! Mock environment used for integration tests.
-use std::collections::HashMap;
-
-use alloy_primitives::{keccak256, Address, Keccak256, B256, U256};
-use polkavm::{
-    Caller, Config, Engine, ExportIndex, GasMeteringKind, Instance, Linker, Module, ModuleConfig,
-    ProgramBlob, Trap,
-};
-use revive_llvm_context::polkavm_const::runtime_api;
-
-/// The mocked blockchain account.
-#[derive(Debug, Default, Clone)]
-struct Account {
-    value: U256,
-    contract: Option<U256>,
-    storage: HashMap<U256, U256>,
-}
-
-/// Emitted event data.
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct Event {
-    pub address: Address,
-    pub data: Vec<u8>,
-    pub topics: Vec<U256>,
-}
-
-/// The result of the contract call.
-#[derive(Debug, Default, Clone)]
-pub struct CallOutput {
-    /// The return flags.
-    pub flags: ReturnFlags,
-    /// The contract call output.
-    pub data: Vec<u8>,
-    /// The emitted events.
-    pub events: Vec<Event>,
-}
-
-/// The contract blob export to be called.
-#[derive(Clone, Debug, Default)]
-enum Export {
-    #[default]
-    Call,
-    Deploy(U256),
-}
-
-/// Possible contract call return flags.
-#[derive(Debug, Default, Clone, PartialEq)]
-#[repr(u32)]
-pub enum ReturnFlags {
-    /// The contract execution returned normally.
-    Success = 0,
-    /// The contract execution returned normally but state changes should be reverted.
-    Revert = 1,
-    /// The contract trapped unexpectedly during execution.
-    #[default]
-    Trap = u32::MAX,
-}
-
-impl From<u32> for ReturnFlags {
-    fn from(value: u32) -> Self {
-        match value {
-            0 => Self::Success,
-            1 => Self::Revert,
-            u32::MAX => Self::Trap,
-            _ => panic!("invalid return flag: {value}"),
-        }
-    }
-}
-
-/// The local context inside the call stack.
-#[derive(Debug, Clone)]
-struct Frame {
-    /// The account that is being executed.
-    callee: Address,
-    /// The caller account.
-    caller: Address,
-    /// The value transferred with this transaction.
-    callvalue: U256,
-    /// The calldata for the contract execution.
-    input: Vec<u8>,
-    // The contract call output.
-    output: CallOutput,
-    /// The export to call.
-    export: Export,
-}
-
-impl Default for Frame {
-    fn default() -> Self {
-        Self {
-            callee: Transaction::default_address(),
-            caller: Transaction::default_address(),
-            callvalue: Default::default(),
-            input: Default::default(),
-            output: Default::default(),
-            export: Default::default(),
-        }
-    }
-}
-
-/// The transaction can modify the state by calling contracts.
-///
-/// Use the [TransactionBuilder] to create new transactions.
-#[derive(Default, Clone, Debug)]
-pub struct Transaction {
-    state: State,
-    stack: Vec<Frame>,
-}
-
-impl Transaction {
-    pub fn default_address() -> Address {
-        Address::default().create2(B256::default(), keccak256([]).0)
-    }
-
-    fn top_frame(&self) -> &Frame {
-        self.stack.last().expect("transactions should have a frame")
-    }
-
-    fn top_frame_mut(&mut self) -> &mut Frame {
-        self.stack
-            .last_mut()
-            .expect("transactions should have a frame")
-    }
-
-    fn top_account_mut(&mut self) -> &mut Account {
-        let account = self.top_frame_mut().callee;
-        self.state
-            .accounts
-            .get_mut(&account)
-            .unwrap_or_else(|| panic!("callee has no associated account: {account}"))
-    }
-
-    fn create2(&self, salt: U256, blob_hash: U256) -> Address {
-        self.top_frame()
-            .callee
-            .create2(salt.to_be_bytes(), blob_hash.to_be_bytes())
-    }
-}
-
-/// Helper to create valid transactions.
-#[derive(Default, Clone, Debug)]
-pub struct TransactionBuilder {
-    context: Transaction,
-    state_before: State,
-}
-
-impl TransactionBuilder {
-    /// Set the caller account.
-    pub fn caller(mut self, account: Address) -> Self {
-        self.context.top_frame_mut().caller = account;
-        self
-    }
-
-    /// Set the callee account.
-    pub fn callee(mut self, account: Address) -> Self {
-        self.context.top_frame_mut().callee = account;
-        self
-    }
-
-    /// Set the transferred callvalue.
-    pub fn callvalue(mut self, amount: U256) -> Self {
-        self.context.top_frame_mut().callvalue = amount;
-        self
-    }
-
-    /// Set the calldata.
-    pub fn calldata(mut self, data: Vec<u8>) -> Self {
-        self.context.top_frame_mut().input = data;
-        self
-    }
-
-    /// Set the transaction to deploy code.
-    pub fn deploy(mut self, code: &[u8]) -> Self {
-        let blob_hash = self.context.state.upload_code(code);
-        self.context.top_frame_mut().export = Export::Deploy(blob_hash);
-        self
-    }
-
-    /// Set the account at [Transaction::default_address] to the given `code`.
-    ///
-    /// Useful helper to spare the deploy transaction.
-    pub fn with_default_account(mut self, code: &[u8]) -> Self {
-        self.context.state.upload_code(code);
-        self.context.state.create_account(
-            Transaction::default_address(),
-            Default::default(),
-            keccak256(code).into(),
-        );
-        self
-    }
-
-    /// Execute the transaction with a default config backend.
-    ///
-    /// Reverts any state changes if the contract reverts or the exuection traps.
-    pub fn call(mut self) -> (State, CallOutput) {
-        let blob_hash = match self.context.top_frame().export {
-            Export::Call => self.context.top_account_mut().contract.unwrap_or_else(|| {
-                panic!(
-                    "not a contract account: {}",
-                    self.context.top_frame().callee
-                )
-            }),
-            Export::Deploy(blob_hash) => blob_hash,
-        };
-        let code = self
-            .context
-            .state
-            .blobs
-            .get(&blob_hash)
-            .unwrap_or_else(|| panic!("contract code not found: {blob_hash}"));
-        let (mut instance, export) = prepare(code, None);
-        self.call_on(&mut instance, export)
-    }
-
-    /// Execute the transaction on a given instance and export.
-    /// The `instance` and `export` are expected to match that of the `Transaction`.
-
-    /// Reverts any state changes if the contract reverts or the exuection traps.
-    pub fn call_on(
-        mut self,
-        instance: &mut Instance<Transaction>,
-        export: ExportIndex,
-    ) -> (State, CallOutput) {
-        let mut state_args = polkavm::StateArgs::default();
-        state_args.set_gas(polkavm::Gas::MAX);
-
-        if let Export::Deploy(blob_hash) = self.context.top_frame().export {
-            self.context.state.create_account(
-                self.context.create2(Default::default(), blob_hash),
-                self.context.top_frame().callvalue,
-                blob_hash,
-            );
-        }
-
-        let callvalue = self.context.top_frame().callvalue;
-        self.context.top_account_mut().value += callvalue;
-
-        let call_args = polkavm::CallArgs::new(&mut self.context, export);
-
-        init_logs();
-
-        match instance.call(state_args, call_args) {
-            Err(polkavm::ExecutionError::Trap(_)) => self.finalize(),
-            Err(other) => panic!("unexpected error: {other}"),
-            Ok(_) => panic!("unexpected return"),
-        }
-    }
-
-    /// Commits or reverts the state changes based on the call flags.
-    fn finalize(mut self) -> (State, CallOutput) {
-        let state = match self.context.top_frame().output.flags {
-            ReturnFlags::Success => self.context.state,
-            _ => self.state_before,
-        };
-        let output = self.context.stack.pop().unwrap().output;
-        (state, output)
-    }
-}
-
-impl From<State> for TransactionBuilder {
-    fn from(state: State) -> Self {
-        TransactionBuilder {
-            state_before: state.clone(),
-            context: Transaction {
-                state,
-                stack: Default::default(),
-            },
-        }
-    }
-}
-
-/// The mocked blockchain state.
-#[derive(Default, Clone, Debug)]
-pub struct State {
-    blobs: HashMap<U256, Vec<u8>>,
-    accounts: HashMap<Address, Account>,
-}
-
-impl State {
-    pub const BLOCK_NUMBER: u64 = 123;
-    pub const BLOCK_TIMESTAMP: u64 = 456;
-
-    pub fn transaction(self) -> TransactionBuilder {
-        TransactionBuilder {
-            state_before: self.clone(),
-            context: Transaction {
-                state: self,
-                stack: vec![Default::default()],
-            },
-        }
-    }
-
-    pub fn upload_code(&mut self, code: &[u8]) -> U256 {
-        let blob_hash = keccak256(code).into();
-        self.blobs.insert(blob_hash, code.to_vec());
-        blob_hash
-    }
-
-    pub fn assert_storage_key(&self, account: Address, key: U256, expected: U256) {
-        assert_eq!(
-            self.accounts
-                .get(&account)
-                .unwrap_or_else(|| panic!("unknown account: {account}"))
-                .storage
-                .get(&key)
-                .copied()
-                .unwrap_or_default(),
-            expected
-        );
-    }
-
-    pub fn create_account(&mut self, address: Address, value: U256, blob_hash: U256) {
-        self.accounts.insert(
-            address,
-            Account {
-                value,
-                contract: Some(blob_hash),
-                storage: HashMap::new(),
-            },
-        );
-    }
-}
-
-fn link_host_functions(engine: &Engine) -> Linker<Transaction> {
-    let mut linker = Linker::new(engine);
-
-    linker
-        .func_wrap(
-            runtime_api::INPUT,
-            |caller: Caller<Transaction>, out_ptr: u32, out_len_ptr: u32| -> Result<(), Trap> {
-                let (mut caller, transaction) = caller.split();
-
-                let input = &transaction.top_frame().input;
-                assert!(input.len() <= caller.read_u32(out_len_ptr).unwrap() as usize);
-
-                caller.write_memory(out_ptr, input)?;
-                caller.write_memory(out_len_ptr, &(input.len() as u32).to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::RETURN,
-            |caller: Caller<Transaction>,
-             flags: u32,
-             data_ptr: u32,
-             data_len: u32|
-             -> Result<(), Trap> {
-                let (caller, transaction) = caller.split();
-
-                let frame = transaction.top_frame_mut();
-                frame.output.flags = flags.into();
-                frame.output.data = caller.read_memory_into_vec(data_ptr, data_len)?;
-
-                Err(Default::default())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::VALUE_TRANSFERRED,
-            |caller: Caller<Transaction>, out_ptr: u32, out_len_ptr: u32| -> Result<(), Trap> {
-                let (mut caller, transaction) = caller.split();
-
-                let out_len = caller.read_u32(out_len_ptr)? as usize;
-                assert_eq!(
-                    out_len,
-                    revive_common::BYTE_LENGTH_VALUE,
-                    "spurious output buffer size: {out_len}"
-                );
-
-                let value = transaction.top_frame().callvalue.as_le_bytes();
-                caller.write_memory(out_ptr, &value)?;
-                caller.write_memory(out_len_ptr, &(value.len() as u32).to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            "debug_message",
-            |caller: Caller<Transaction>, str_ptr: u32, str_len: u32| -> Result<u32, Trap> {
-                let (caller, _) = caller.split();
-
-                let data = caller.read_memory_into_vec(str_ptr, str_len)?;
-                print!("debug_message: {}", String::from_utf8(data).unwrap());
-
-                Ok(0)
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::SET_STORAGE,
-            |caller: Caller<Transaction>,
-             key_ptr: u32,
-             key_len: u32,
-             value_ptr: u32,
-             value_len: u32|
-             -> Result<u32, Trap> {
-                let (caller, transaction) = caller.split();
-
-                assert_eq!(
-                    key_len as usize,
-                    revive_common::BYTE_LENGTH_WORD,
-                    "storage key must be 32 bytes"
-                );
-                assert_eq!(
-                    value_len as usize,
-                    revive_common::BYTE_LENGTH_WORD,
-                    "storage value must be 32 bytes"
-                );
-
-                let key = caller.read_memory_into_vec(key_ptr, key_len)?;
-                let value = caller.read_memory_into_vec(value_ptr, value_len)?;
-
-                transaction.top_account_mut().storage.insert(
-                    U256::from_be_bytes::<32>(key.try_into().unwrap()),
-                    U256::from_be_bytes::<32>(value.try_into().unwrap()),
-                );
-
-                Ok(0)
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::GET_STORAGE,
-            |caller: Caller<Transaction>,
-             key_ptr: u32,
-             key_len: u32,
-             out_ptr: u32,
-             out_len_ptr: u32|
-             -> Result<u32, Trap> {
-                let (mut caller, transaction) = caller.split();
-
-                let key = caller.read_memory_into_vec(key_ptr, key_len)?;
-                let out_len = caller.read_u32(out_len_ptr)? as usize;
-                assert_eq!(
-                    out_len,
-                    revive_common::BYTE_LENGTH_WORD,
-                    "spurious output buffer size: {out_len}"
-                );
-
-                let value = transaction
-                    .top_account_mut()
-                    .storage
-                    .get(&U256::from_be_bytes::<32>(key.try_into().unwrap()))
-                    .map(U256::to_be_bytes::<32>)
-                    .unwrap_or_default();
-
-                caller.write_memory(out_ptr, &value[..])?;
-                caller.write_memory(out_len_ptr, &32u32.to_le_bytes())?;
-
-                Ok(0)
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::HASH_KECCAK_256,
-            |caller: Caller<Transaction>,
-             input_ptr: u32,
-             input_len: u32,
-             out_ptr: u32|
-             -> Result<(), Trap> {
-                let (mut caller, _) = caller.split();
-
-                let pre = caller.read_memory_into_vec(input_ptr, input_len)?;
-
-                let mut hasher = Keccak256::new();
-                hasher.update(&pre);
-                caller.write_memory(out_ptr, &hasher.finalize()[..])?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::NOW,
-            |caller: Caller<Transaction>, out_ptr: u32, out_len_ptr: u32| {
-                let (mut caller, _) = caller.split();
-
-                let out_len = caller.read_u32(out_len_ptr)? as usize;
-                assert_eq!(
-                    out_len,
-                    revive_common::BYTE_LENGTH_BLOCK_TIMESTAMP,
-                    "spurious output buffer size: {out_len}"
-                );
-
-                caller.write_memory(out_ptr, &State::BLOCK_TIMESTAMP.to_le_bytes())?;
-                caller.write_memory(out_len_ptr, &64u32.to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::BLOCK_NUMBER,
-            |caller: Caller<Transaction>, out_ptr: u32, out_len_ptr: u32| {
-                let (mut caller, _) = caller.split();
-
-                let out_len = caller.read_u32(out_len_ptr)? as usize;
-                assert_eq!(
-                    out_len,
-                    revive_common::BYTE_LENGTH_BLOCK_NUMBER,
-                    "spurious output buffer size: {out_len}"
-                );
-
-                caller.write_memory(out_ptr, &State::BLOCK_NUMBER.to_le_bytes())?;
-                caller.write_memory(out_len_ptr, &64u32.to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::ADDRESS,
-            |caller: Caller<Transaction>, out_ptr: u32, out_len_ptr: u32| {
-                let (mut caller, transaction) = caller.split();
-
-                let out_len = caller.read_u32(out_len_ptr)? as usize;
-                assert_eq!(
-                    out_len,
-                    revive_common::BYTE_LENGTH_ETH_ADDRESS,
-                    "spurious output buffer size: {out_len}"
-                );
-
-                let address = transaction.top_frame().callee.as_slice();
-                caller.write_memory(out_ptr, address)?;
-                caller.write_memory(out_len_ptr, &(address.len() as u32).to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::CALLER,
-            |caller: Caller<Transaction>, out_ptr: u32, out_len_ptr: u32| {
-                let (mut caller, transaction) = caller.split();
-
-                let out_len = caller.read_u32(out_len_ptr)? as usize;
-                assert_eq!(
-                    out_len,
-                    revive_common::BYTE_LENGTH_ETH_ADDRESS,
-                    "spurious output buffer size: {out_len}"
-                );
-
-                let address = transaction.top_frame().caller.as_slice();
-                caller.write_memory(out_ptr, address)?;
-                caller.write_memory(out_len_ptr, &(address.len() as u32).to_le_bytes())?;
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-        .func_wrap(
-            runtime_api::DEPOSIT_EVENT,
-            |caller: Caller<Transaction>,
-             topics_ptr: u32,
-             topics_len: u32,
-             data_ptr: u32,
-             data_len: u32| {
-                let (caller, transaction) = caller.split();
-
-                let address = transaction.top_frame().callee;
-                let data = if data_len != 0 {
-                    caller.read_memory_into_vec(data_ptr, data_len)?
-                } else {
-                    Default::default()
-                };
-                let topics = if topics_len != 0 {
-                    caller
-                        .read_memory_into_vec(topics_ptr, topics_len)?
-                        .chunks(32)
-                        .map(|chunk| U256::from_be_slice(chunk))
-                        .collect()
-                } else {
-                    Default::default()
-                };
-
-                transaction.top_frame_mut().output.events.push(Event {
-                    address,
-                    data,
-                    topics,
-                });
-
-                Ok(())
-            },
-        )
-        .unwrap();
-
-    linker
-}
-
-pub fn setup(config: Option<Config>) -> Engine {
-    Engine::new(&config.unwrap_or_default()).unwrap()
-}
-
-pub fn recompile_code(code: &[u8], engine: &Engine) -> Module {
-    let mut module_config = ModuleConfig::new();
-    module_config.set_gas_metering(Some(GasMeteringKind::Sync));
-
-    Module::new(engine, &module_config, code).unwrap()
-}
-
-pub fn instantiate_module(
-    module: &Module,
-    engine: &Engine,
-) -> (Instance<Transaction>, ExportIndex) {
-    let export = module.lookup_export(runtime_api::CALL).unwrap();
-    let func = link_host_functions(engine).instantiate_pre(module).unwrap();
-    let instance = func.instantiate().unwrap();
-
-    (instance, export)
-}
-
-pub fn prepare(code: &[u8], config: Option<Config>) -> (Instance<Transaction>, ExportIndex) {
-    let blob = ProgramBlob::parse(code).unwrap();
-
-    let engine = Engine::new(&config.unwrap_or_default()).unwrap();
-
-    let mut module_config = ModuleConfig::new();
-    module_config.set_gas_metering(Some(GasMeteringKind::Sync));
-
-    let module = Module::from_blob(&engine, &module_config, &blob).unwrap();
-    let export = module.lookup_export(runtime_api::CALL).unwrap();
-    let func = link_host_functions(&engine)
-        .instantiate_pre(&module)
-        .unwrap();
-    let instance = func.instantiate().unwrap();
-
-    (instance, export)
-}
-
-fn init_logs() {
-    if std::env::var("RUST_LOG").is_ok() {
-        #[cfg(test)]
-        let test = true;
-        #[cfg(not(test))]
-        let test = false;
-        let _ = env_logger::builder().is_test(test).try_init();
-    }
-}

crates/integration/src/tests.rs

@@ -1,423 +1,375 @@
-use alloy_primitives::{keccak256, Address, FixedBytes, I256, U256};
+use std::str::FromStr;
-use alloy_sol_types::{sol, SolCall};
-use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
-use sha1::Digest;
 
-use crate::{
+use alloy_primitives::*;
-    assert_success,
+use revive_runner::*;
-    cases::Contract,
+use SpecsAction::*;
-    mock_runtime::{self, ReturnFlags, State, Transaction},
-};
 
-#[test]
+use crate::cases::Contract;
-fn fibonacci() {
-    let parameter = 6;
 
-    for contract in [
+/// Parameters:
-        Contract::fib_recursive(parameter),
+/// - The function name of the test
-        Contract::fib_iterative(parameter),
+/// - The contract name to fill in empty code based on the file path
-        Contract::fib_binet(parameter),
+/// - The contract source file
-    ] {
+macro_rules! test_spec {
-        let (_, output) = assert_success(&contract, true);
+    ($test_name:ident, $contract_name:literal, $source_file:literal) => {
-        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+        #[test]
-        let expected = U256::from(8);
+        fn $test_name() {
-        assert_eq!(received, expected);
+            let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("should always exist");
+            let path = format!("{manifest_dir}/../integration/contracts/{}", $source_file);
+            Specs::from_comment($contract_name, &path).remove(0).run();
         }
+    };
 }
 
-#[test]
+test_spec!(baseline, "Baseline", "Baseline.sol");
-fn flipper() {
+test_spec!(flipper, "Flipper", "flipper.sol");
-    let contract = Contract::flipper();
+test_spec!(fibonacci_recursive, "FibonacciRecursive", "Fibonacci.sol");
-    let address = Transaction::default_address();
+test_spec!(fibonacci_iterative, "FibonacciIterative", "Fibonacci.sol");
+test_spec!(fibonacci_binet, "FibonacciBinet", "Fibonacci.sol");
+test_spec!(hash_keccak_256, "TestSha3", "Crypto.sol");
+test_spec!(erc20, "ERC20", "ERC20.sol");
+test_spec!(computation, "Computation", "Computation.sol");
+test_spec!(msize, "MSize", "MSize.sol");
+test_spec!(sha1, "SHA1", "SHA1.sol");
+test_spec!(block, "Block", "Block.sol");
+test_spec!(mcopy, "MCopy", "MCopy.sol");
+test_spec!(events, "Events", "Events.sol");
+test_spec!(storage, "Storage", "Storage.sol");
+test_spec!(mstore8, "MStore8", "MStore8.sol");
+test_spec!(address, "Context", "Context.sol");
+test_spec!(balance, "Value", "Value.sol");
+test_spec!(create, "CreateB", "Create.sol");
+test_spec!(call, "Caller", "Call.sol");
+test_spec!(transfer, "Transfer", "Transfer.sol");
+test_spec!(return_data_oob, "ReturnDataOob", "ReturnDataOob.sol");
+test_spec!(immutables, "Immutables", "Immutables.sol");
 
-    let (state, output) = contract.execute();
+fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
-    assert_eq!(output.flags, ReturnFlags::Success);
+    vec![Instantiate {
-    state.assert_storage_key(address, U256::ZERO, U256::from(1));
+        origin: TestAddress::Alice,
-
+        value: 0,
-    let (state, output) = state.transaction().calldata(contract.calldata).call();
+        gas_limit: Some(GAS_LIMIT),
-    assert_eq!(output.flags, ReturnFlags::Success);
+        storage_deposit_limit: None,
-    state.assert_storage_key(address, U256::ZERO, U256::ZERO);
+        code: Code::Solidity {
+            path: Some(path.into()),
+            contract: contract.to_string(),
+            solc_optimizer: None,
+            pipeline: None,
+        },
+        data: vec![],
+        salt: OptionalHex::default(),
+    }]
 }
 
-#[test]
+fn run_differential(actions: Vec<SpecsAction>) {
-fn hash_keccak_256() {
+    Specs {
-    sol!(
+        differential: true,
-        #[derive(Debug, PartialEq, Eq)]
+        actions,
-        contract TestSha3 {
+        ..Default::default()
-            function test(string memory _pre) external payable returns (bytes32);
     }
-    );
+    .run();
-    let source = r#"contract TestSha3 {
-            function test(string memory _pre) external payable returns (bytes32 hash) {
-                hash = keccak256(bytes(_pre));
-            }
-        }"#;
-    let code = crate::compile_blob("TestSha3", source);
-
-    let param = "hello";
-    let input = TestSha3::testCall::new((param.to_string(),)).abi_encode();
-
-    let (_, output) = State::default()
-        .transaction()
-        .with_default_account(&code)
-        .calldata(input)
-        .call();
-
-    assert_eq!(output.flags, ReturnFlags::Success);
-
-    let expected = keccak256(param.as_bytes());
-    let received = FixedBytes::<32>::from_slice(&output.data);
-    assert_eq!(received, expected);
 }
 
 #[test]
-fn erc20() {
+fn bitwise_byte() {
-    let _ = crate::compile_blob("ERC20", include_str!("../contracts/ERC20.sol"));
+    let mut actions = instantiate("contracts/Bitwise.sol", "Bitwise");
-}
 
-#[test]
+    let de_bruijn_sequence =
-fn triangle_number() {
+        hex::decode("4060503824160d0784426150b864361d0f88c4a27148ac5a2f198d46e391d8f4").unwrap();
-    let (_, output) = assert_success(&Contract::triangle_number(13), true);
+    let value = U256::from_be_bytes::<32>(de_bruijn_sequence.clone().try_into().unwrap());
-    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+    for input in de_bruijn_sequence
-    let expected = U256::try_from(91).unwrap();
+        .iter()
-    assert_eq!(received, expected);
+        .enumerate()
-}
+        .map(|(index, _)| Contract::bitwise_byte(U256::from(index), value).calldata)
-
+        .chain([
-#[test]
+            Contract::bitwise_byte(U256::ZERO, U256::ZERO).calldata,
-fn odd_product() {
+            Contract::bitwise_byte(U256::ZERO, U256::MAX).calldata,
-    let (_, output) = assert_success(&Contract::odd_product(5), true);
+            Contract::bitwise_byte(U256::MAX, U256::ZERO).calldata,
-    let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
+            Contract::bitwise_byte(U256::from_str("18446744073709551619").unwrap(), U256::MAX)
-    let expected = I256::try_from(945i64).unwrap();
+                .calldata,
-    assert_eq!(received, expected);
+        ])
-}
-
-#[test]
-fn msize_plain() {
-    sol!(
-        #[derive(Debug, PartialEq, Eq)]
-        contract MSize {
-            function mSize() public pure returns (uint);
-        }
-    );
-    let code = crate::compile_blob_with_options(
-        "MSize",
-        include_str!("../contracts/MSize.sol"),
-        false,
-        revive_solidity::SolcPipeline::EVMLA,
-    );
-
-    let input = MSize::mSizeCall::new(()).abi_encode();
-    let (_, output) = State::default()
-        .transaction()
-        .calldata(input)
-        .with_default_account(&code)
-        .call();
-
-    assert_eq!(output.flags, ReturnFlags::Success);
-
-    // Solidity always stores the "free memory pointer" (32 byte int) at offset 64.
-    let expected = U256::try_from(64 + 32).unwrap();
-    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn transferred_value() {
-    sol!(
-        contract Value {
-            function value() public payable returns (uint);
-        }
-    );
-    let code = crate::compile_blob("Value", include_str!("../contracts/Value.sol"));
-
-    let (_, output) = State::default()
-        .transaction()
-        .calldata(Value::valueCall::SELECTOR.to_vec())
-        .callvalue(U256::from(123))
-        .with_default_account(&code)
-        .call();
-
-    assert_eq!(output.flags, ReturnFlags::Success);
-
-    let expected = I256::try_from(123).unwrap();
-    let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn msize_non_word_sized_access() {
-    sol!(
-        #[derive(Debug, PartialEq, Eq)]
-        contract MSize {
-            function mStore100() public pure returns (uint);
-        }
-    );
-    let code = crate::compile_blob_with_options(
-        "MSize",
-        include_str!("../contracts/MSize.sol"),
-        false,
-        revive_solidity::SolcPipeline::Yul,
-    );
-
-    let input = MSize::mStore100Call::new(()).abi_encode();
-    let (_, output) = State::default()
-        .transaction()
-        .with_default_account(&code)
-        .calldata(input)
-        .call();
-
-    assert_eq!(output.flags, ReturnFlags::Success);
-
-    // https://docs.zksync.io/build/developer-reference/differences-with-ethereum.html#mstore-mload
-    // "Unlike EVM, where the memory growth is in words, on zkEVM the memory growth is counted in bytes."
-    // "For example, if you write mstore(100, 0) the msize on zkEVM will be 132, but on the EVM it will be 160."
-    let expected = U256::try_from(132).unwrap();
-    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn mstore8() {
-    for (received, expected) in [
-        (U256::MIN, U256::MIN),
-        (
-            U256::from(1),
-            U256::from_str_radix(
-                "452312848583266388373324160190187140051835877600158453279131187530910662656",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(2),
-            U256::from_str_radix(
-                "904625697166532776746648320380374280103671755200316906558262375061821325312",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(255),
-            U256::from_str_radix(
-                "115339776388732929035197660848497720713218148788040405586178452820382218977280",
-                10,
-            )
-            .unwrap(),
-        ),
-        (U256::from(256), U256::from(0)),
-        (
-            U256::from(257),
-            U256::from_str_radix(
-                "452312848583266388373324160190187140051835877600158453279131187530910662656",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(258),
-            U256::from_str_radix(
-                "904625697166532776746648320380374280103671755200316906558262375061821325312",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::from(123456789),
-            U256::from_str_radix(
-                "9498569820248594155839807363993929941088553429603327518861754938149123915776",
-                10,
-            )
-            .unwrap(),
-        ),
-        (
-            U256::MAX,
-            U256::from_str_radix(
-                "115339776388732929035197660848497720713218148788040405586178452820382218977280",
-                10,
-            )
-            .unwrap(),
-        ),
-    ]
-    .par_iter()
-    .map(|(parameter, expected)| {
-        let (_, output) = assert_success(&Contract::mstore8(*parameter), true);
-        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
-        (received, *expected)
-    })
-    .collect::<Vec<_>>()
     {
-        assert_eq!(received, expected);
+        actions.push(Call {
+            origin: TestAddress::Alice,
+            dest: TestAddress::Instantiated(0),
+            value: 0,
+            gas_limit: None,
+            storage_deposit_limit: None,
+            data: input,
+        })
     }
-}
 
-#[test]
+    run_differential(actions);
-fn sha1() {
-    let pre = vec![0xffu8; 512];
-    let mut hasher = sha1::Sha1::new();
-    hasher.update(&pre);
-    let hash = hasher.finalize();
-
-    let (_, output) = assert_success(&Contract::sha1(pre), true);
-    let expected = FixedBytes::<20>::from_slice(&hash[..]);
-    let received = FixedBytes::<20>::from_slice(&output.data[..20]);
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn block_number() {
-    let (_, output) = assert_success(&Contract::block_number(), true);
-    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
-    let expected = U256::from(mock_runtime::State::BLOCK_NUMBER);
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn block_timestamp() {
-    let (_, output) = assert_success(&Contract::block_timestamp(), true);
-    let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
-    let expected = U256::from(mock_runtime::State::BLOCK_TIMESTAMP);
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn address() {
-    let contract = Contract::context_address();
-    let (_, output) = assert_success(&contract, true);
-    let received = Address::from_slice(&output.data[12..]);
-    let expected = Transaction::default_address();
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn caller() {
-    let (_, output) = assert_success(&Contract::context_caller(), true);
-    let received = Address::from_slice(&output.data[12..]);
-    let expected = Transaction::default_address();
-    assert_eq!(received, expected);
 }
 
 #[test]
 fn unsigned_division() {
+    let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
+
     let one = U256::from(1);
     let two = U256::from(2);
     let five = U256::from(5);
-    for (received, expected) in [
+    for (n, d) in [
-        (five, five, one),
+        (five, five),
-        (five, one, five),
+        (five, one),
-        (U256::ZERO, U256::MAX, U256::ZERO),
+        (U256::ZERO, U256::MAX),
-        (five, two, two),
+        (five, two),
-        (one, U256::ZERO, U256::ZERO),
+        (one, U256::ZERO),
-    ]
+    ] {
-    .par_iter()
+        actions.push(Call {
-    .map(|(n, d, q)| {
+            origin: TestAddress::Alice,
-        let (_, output) = assert_success(&Contract::division_arithmetics_div(*n, *d), true);
+            dest: TestAddress::Instantiated(0),
-        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+            value: 0,
-        (received, *q)
+            gas_limit: None,
+            storage_deposit_limit: None,
+            data: Contract::division_arithmetics_div(n, d).calldata,
         })
-    .collect::<Vec<_>>()
-    {
-        assert_eq!(received, expected)
     }
+
+    run_differential(actions);
 }
 
 #[test]
 fn signed_division() {
+    let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
+
     let one = I256::try_from(1).unwrap();
     let two = I256::try_from(2).unwrap();
     let minus_two = I256::try_from(-2).unwrap();
     let five = I256::try_from(5).unwrap();
     let minus_five = I256::try_from(-5).unwrap();
-    for (received, expected) in [
+    for (n, d) in [
-        (five, five, one),
+        (five, five),
-        (five, one, five),
+        (five, one),
-        (I256::ZERO, I256::MAX, I256::ZERO),
+        (I256::ZERO, I256::MAX),
-        (I256::ZERO, I256::MINUS_ONE, I256::ZERO),
+        (I256::ZERO, I256::MINUS_ONE),
-        (five, two, two),
+        (five, two),
-        (five, I256::MINUS_ONE, minus_five),
+        (five, I256::MINUS_ONE),
-        (I256::MINUS_ONE, minus_two, I256::ZERO),
+        (I256::MINUS_ONE, minus_two),
-        (minus_five, minus_five, one),
+        (minus_five, minus_five),
-        (minus_five, two, minus_two),
+        (minus_five, two),
-        (I256::MINUS_ONE, I256::MIN, I256::ZERO),
+        (I256::MINUS_ONE, I256::MIN),
-        (one, I256::ZERO, I256::ZERO),
+        (one, I256::ZERO),
-    ]
+    ] {
-    .par_iter()
+        actions.push(Call {
-    .map(|(n, d, q)| {
+            origin: TestAddress::Alice,
-        let (_, output) = assert_success(&Contract::division_arithmetics_sdiv(*n, *d), true);
+            dest: TestAddress::Instantiated(0),
-        let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
+            value: 0,
-        (received, *q)
+            gas_limit: None,
+            storage_deposit_limit: None,
+            data: Contract::division_arithmetics_sdiv(n, d).calldata,
         })
-    .collect::<Vec<_>>()
-    {
-        assert_eq!(received, expected);
     }
+
+    run_differential(actions);
 }
 
 #[test]
 fn unsigned_remainder() {
+    let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
+
     let one = U256::from(1);
     let two = U256::from(2);
     let five = U256::from(5);
-    for (received, expected) in [
+    for (n, d) in [
-        (five, five, U256::ZERO),
+        (five, five),
-        (five, one, U256::ZERO),
+        (five, one),
-        (U256::ZERO, U256::MAX, U256::ZERO),
+        (U256::ZERO, U256::MAX),
-        (U256::MAX, U256::MAX, U256::ZERO),
+        (U256::MAX, U256::MAX),
-        (five, two, one),
+        (five, two),
-        (two, five, two),
+        (two, five),
-        (U256::MAX, U256::ZERO, U256::ZERO),
+        (U256::MAX, U256::ZERO),
-    ]
+    ] {
-    .par_iter()
+        actions.push(Call {
-    .map(|(n, d, q)| {
+            origin: TestAddress::Alice,
-        let (_, output) = assert_success(&Contract::division_arithmetics_mod(*n, *d), true);
+            dest: TestAddress::Instantiated(0),
-        let received = U256::from_be_bytes::<32>(output.data.try_into().unwrap());
+            value: 0,
-        (received, *q)
+            gas_limit: None,
+            storage_deposit_limit: None,
+            data: Contract::division_arithmetics_mod(n, d).calldata,
         })
-    .collect::<Vec<_>>()
-    {
-        assert_eq!(received, expected);
     }
+
+    run_differential(actions);
 }
 
 #[test]
 fn signed_remainder() {
+    let mut actions = instantiate("contracts/DivisionArithmetics.sol", "DivisionArithmetics");
+
     let one = I256::try_from(1).unwrap();
     let two = I256::try_from(2).unwrap();
     let minus_two = I256::try_from(-2).unwrap();
     let five = I256::try_from(5).unwrap();
     let minus_five = I256::try_from(-5).unwrap();
-    for (received, expected) in [
+    for (n, d) in [
-        (five, five, I256::ZERO),
+        (five, five),
-        (five, one, I256::ZERO),
+        (five, one),
-        (I256::ZERO, I256::MAX, I256::ZERO),
+        (I256::ZERO, I256::MAX),
-        (I256::MAX, I256::MAX, I256::ZERO),
+        (I256::MAX, I256::MAX),
-        (five, two, one),
+        (five, two),
-        (two, five, two),
+        (two, five),
-        (five, minus_five, I256::ZERO),
+        (five, minus_five),
-        (five, I256::MINUS_ONE, I256::ZERO),
+        (five, I256::MINUS_ONE),
-        (five, minus_two, one),
+        (five, minus_two),
-        (minus_five, two, I256::MINUS_ONE),
+        (minus_five, two),
-        (minus_two, five, minus_two),
+        (minus_two, five),
-        (minus_five, minus_five, I256::ZERO),
+        (minus_five, minus_five),
-        (minus_five, I256::MINUS_ONE, I256::ZERO),
+        (minus_five, I256::MINUS_ONE),
-        (minus_five, minus_two, I256::MINUS_ONE),
+        (minus_five, minus_two),
-        (minus_two, minus_five, minus_two),
+        (minus_two, minus_five),
-        (I256::MIN, I256::MINUS_ONE, I256::ZERO),
+        (I256::MIN, I256::MINUS_ONE),
-        (I256::ZERO, I256::ZERO, I256::ZERO),
+        (I256::ZERO, I256::ZERO),
-    ]
+    ] {
-    .par_iter()
+        actions.push(Call {
-    .map(|(n, d, q)| {
+            origin: TestAddress::Alice,
-        let (_, output) = assert_success(&Contract::division_arithmetics_smod(*n, *d), true);
+            dest: TestAddress::Instantiated(0),
-        let received = I256::from_be_bytes::<32>(output.data.try_into().unwrap());
+            value: 0,
-        (received, *q)
+            gas_limit: None,
+            storage_deposit_limit: None,
+            data: Contract::division_arithmetics_smod(n, d).calldata,
         })
-    .collect::<Vec<_>>()
-    {
-        assert_eq!(received, expected);
     }
+
+    run_differential(actions);
 }
 
 #[test]
-fn events() {
+fn ext_code_hash() {
-    assert_success(&Contract::event(U256::ZERO), true);
+    let mut actions = instantiate("contracts/ExtCode.sol", "ExtCode");
-    assert_success(&Contract::event(U256::from(123)), true);
+
+    // First do contract instantiation to figure out address and code hash
+    let results = Specs {
+        actions: actions.clone(),
+        ..Default::default()
+    }
+    .run();
+    let (addr, code_hash) = match results.first().cloned() {
+        Some(CallResult::Instantiate {
+            result, code_hash, ..
+        }) => (result.result.unwrap().addr, code_hash),
+        _ => panic!("instantiate contract failed"),
+    };
+
+    // code hash of itself
+    actions.push(Call {
+        origin: TestAddress::Alice,
+        dest: TestAddress::Instantiated(0),
+        value: 0,
+        gas_limit: None,
+        storage_deposit_limit: None,
+        data: Contract::code_hash().calldata,
+    });
+    actions.push(VerifyCall(VerifyCallExpectation {
+        success: true,
+        output: OptionalHex::from(code_hash.as_bytes().to_vec()),
+        gas_consumed: None,
+    }));
+
+    // code hash for a given contract address
+    actions.push(Call {
+        origin: TestAddress::Alice,
+        dest: TestAddress::Instantiated(0),
+        value: 0,
+        gas_limit: None,
+        storage_deposit_limit: None,
+        data: Contract::ext_code_hash(Address::from(addr.to_fixed_bytes())).calldata,
+    });
+    actions.push(VerifyCall(VerifyCallExpectation {
+        success: true,
+        output: OptionalHex::from(code_hash.as_bytes().to_vec()),
+        gas_consumed: None,
+    }));
+
+    // EOA returns fixed hash
+    actions.push(Call {
+        origin: TestAddress::Alice,
+        dest: TestAddress::Instantiated(0),
+        value: 0,
+        gas_limit: None,
+        storage_deposit_limit: None,
+        data: Contract::ext_code_hash(Address::from(CHARLIE.to_fixed_bytes())).calldata,
+    });
+    actions.push(VerifyCall(VerifyCallExpectation {
+        success: true,
+        output: OptionalHex::from(
+            hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").to_vec(),
+        ),
+        gas_consumed: None,
+    }));
+
+    // non-existing account
+    actions.push(Call {
+        origin: TestAddress::Alice,
+        dest: TestAddress::Instantiated(0),
+        value: 0,
+        gas_limit: None,
+        storage_deposit_limit: None,
+        data: Contract::ext_code_hash(Address::from([8u8; 20])).calldata,
+    });
+    actions.push(VerifyCall(VerifyCallExpectation {
+        success: true,
+        output: OptionalHex::from([0u8; 32].to_vec()),
+        gas_consumed: None,
+    }));
+
+    Specs {
+        actions,
+        ..Default::default()
+    }
+    .run();
 }
+
+/*
+// These test were implement for the mock-runtime and need to be ported yet.
+
+#[test]
+fn create2_failure() {
+    let mut state = State::default();
+    let contract_a = Contract::create_a();
+    state.upload_code(&contract_a.pvm_runtime);
+
+    let contract = Contract::create_b();
+    let (state, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata.clone())
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Success);
+
+    // The address already exists, which should cause the contract to revert
+
+    let (_, output) = state
+        .transaction()
+        .with_default_account(&contract.pvm_runtime)
+        .calldata(contract.calldata)
+        .call();
+
+    assert_eq!(output.flags, ReturnFlags::Revert);
+}
+
+#[test]
+fn ext_code_size() {
+    let contract = Contract::ext_code_size(Transaction::default_address());
+    let (_, output) = assert_success(&contract, false);
+    let received = U256::from_be_slice(&output.data);
+    let expected = U256::from(contract.pvm_runtime.len());
+    assert_eq!(received, expected);
+
+    let contract = Contract::ext_code_size(Default::default());
+    let (_, output) = assert_success(&contract, false);
+    let received = U256::from_be_slice(&output.data);
+    let expected = U256::ZERO;
+    assert_eq!(received, expected);
+}
+
+#[test]
+fn code_size() {
+    let contract = Contract::code_size();
+    let (_, output) = assert_success(&contract, false);
+    let expected = U256::from(contract.pvm_runtime.len());
+    let received = U256::from_be_slice(&output.data);
+    assert_eq!(expected, received);
+}
+*/

crates/linker/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
 name = "revive-linker"
-version = "0.1.0"
+version.workspace = true
-edition = "2021"
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
+description = "revive compiler linker utils"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+riscv-64 = []
 
 [dependencies]
 inkwell = { workspace = true }
@@ -13,5 +18,5 @@ polkavm-common = { workspace = true }
 libc = { workspace = true }
 anyhow = { workspace = true }
 
-revive-builtins = { path = "../builtins" }
+revive-builtins = { workspace = true }
-lld-sys = { path = "../lld-sys" }
+lld-sys = { workspace = true }

crates/linker/src/lib.rs

@@ -8,6 +8,16 @@ SECTIONS {
     .text : { KEEP(*(.text.polkavm_export)) *(.text .text.*) }
 }"#;
 
+#[cfg(not(feature = "riscv-64"))]
+const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv32.a";
+#[cfg(feature = "riscv-64")]
+const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
+
+#[cfg(not(feature = "riscv-64"))]
+const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv32";
+#[cfg(feature = "riscv-64")]
+const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv64";
+
 fn invoke_lld(cmd_args: &[&str]) -> bool {
     let c_strings = cmd_args
         .iter()
@@ -22,9 +32,9 @@ fn invoke_lld(cmd_args: &[&str]) -> bool {
 fn polkavm_linker<T: AsRef<[u8]>>(code: T) -> anyhow::Result<Vec<u8>> {
     let mut config = polkavm_linker::Config::default();
     config.set_strip(true);
+    config.set_optimize(true);
 
     polkavm_linker::program_from_elf(config, code.as_ref())
-        .map(|blob| blob.as_bytes().to_vec())
         .map_err(|reason| anyhow::anyhow!("polkavm linker failed: {}", reason))
 }
 
@@ -33,7 +43,7 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
     let output_path = dir.path().join("out.so");
     let object_path = dir.path().join("out.o");
     let linker_script_path = dir.path().join("linker.ld");
-    let compiler_rt_path = dir.path().join("libclang_rt.builtins-riscv32.a");
+    let compiler_rt_path = dir.path().join(BUILTINS_ARCHIVE_FILE);
 
     fs::write(&object_path, input).map_err(|msg| anyhow::anyhow!("{msg} {object_path:?}"))?;
 
@@ -58,7 +68,7 @@ pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
         "--library-path",
         dir.path().to_str().expect("should be utf8"),
         "--library",
-        "clang_rt.builtins-riscv32",
+        BUILTINS_LIB_NAME,
         linker_script_path.to_str().expect("should be utf8"),
         object_path.to_str().expect("should be utf8"),
         "-o",

crates/lld-sys/Cargo.toml

@@ -1,11 +1,12 @@
 [package]
 name = "lld-sys"
-version = "0.1.0"
+version.workspace = true
-edition = "2021"
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+authors.workspace = true
 build = "build.rs"
-
+description = "bindings for ld.lld core"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 libc = { workspace = true }

crates/lld-sys/build.rs

@@ -27,7 +27,10 @@ fn set_rustc_link_flags() {
     }
 
     #[cfg(target_os = "linux")]
+    {
         println!("cargo:rustc-link-lib=dylib=stdc++");
+        println!("cargo:rustc-link-lib=tinfo");
+    }
 }
 
 fn main() {

crates/llvm-context/Cargo.toml

@@ -1,12 +1,13 @@
 [package]
 name = "revive-llvm-context"
-version = "1.4.1"
+version.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
 authors = [
     "Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
     "Cyrill Leutwiler <cyrill@parity.io>",
 ]
-license = "MIT OR Apache-2.0"
-edition = "2021"
 description = "Shared front end code of the revive PolkaVM compilers"
 
 [lib]
@@ -14,6 +15,7 @@ doctest = false
 
 [features]
 riscv-zbb = []
+riscv-64 = []
 
 [dependencies]
 anyhow = { workspace = true }
@@ -31,10 +33,8 @@ inkwell = { workspace = true }
 polkavm-disassembler = { workspace = true }
 polkavm-common = { workspace = true }
 
-zkevm_opcode_defs = { git = "https://github.com/matter-labs/era-zkevm_opcode_defs", branch = "v1.4.1" }
+revive-common = { workspace = true }
-revive-common = { path = "../common" }
+revive-runtime-api = { workspace = true }
-
+revive-linker = { workspace = true }
-pallet-contracts-pvm-llapi = { path = "../pallet-contracts-pvm-llapi" }
+revive-builtins = { workspace = true }
-revive-linker = { path = "../linker" }
+revive-stdlib = { workspace = true }
-revive-builtins = { path = "../builtins" }
-revive-stdlib = { path = "../stdlib" }

crates/llvm-context/src/debug_config/ir_type.rs

@@ -11,12 +11,13 @@ pub enum IRType {
     EVMLA,
     /// Whether to dump the Ethereal IR code.
     EthIR,
-    /// Whether to dump the Vyper LLL IR code.
-    LLL,
     /// Whether to dump the LLVM IR code.
     LLVM,
     /// Whether to dump the assembly code.
     Assembly,
+    /// Whether to jump JSON
+    #[cfg(debug_assertions)]
+    JSON,
 }
 
 impl IRType {
@@ -26,9 +27,10 @@ impl IRType {
             Self::Yul => revive_common::EXTENSION_YUL,
             Self::EthIR => revive_common::EXTENSION_ETHIR,
             Self::EVMLA => revive_common::EXTENSION_EVMLA,
-            Self::LLL => revive_common::EXTENSION_LLL,
             Self::LLVM => revive_common::EXTENSION_LLVM_SOURCE,
             Self::Assembly => revive_common::EXTENSION_POLKAVM_ASSEMBLY,
+            #[cfg(debug_assertions)]
+            Self::JSON => revive_common::EXTENSION_JSON,
         }
     }
 }

crates/llvm-context/src/debug_config/mod.rs

@@ -52,16 +52,6 @@ impl DebugConfig {
         Ok(())
     }
 
-    /// Dumps the LLL IR.
-    pub fn dump_lll(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        let mut file_path = self.output_directory.to_owned();
-        let full_file_name = Self::full_file_name(contract_path, None, IRType::LLL);
-        file_path.push(full_file_name);
-        std::fs::write(file_path, code)?;
-
-        Ok(())
-    }
-
     /// Dumps the unoptimized LLVM IR.
     pub fn dump_llvm_ir_unoptimized(
         &self,
@@ -104,6 +94,22 @@ impl DebugConfig {
         Ok(())
     }
 
+    /// Dumps the stage output as a json file suitable for use with --recursive-process
+    #[cfg(debug_assertions)]
+    pub fn dump_stage_output(
+        &self,
+        contract_path: &str,
+        contract_suffix: Option<&str>,
+        stage_json: &Vec<u8>,
+    ) -> anyhow::Result<()> {
+        let mut file_path = self.output_directory.to_owned();
+        let full_file_name = Self::full_file_name(contract_path, contract_suffix, IRType::JSON);
+        file_path.push(full_file_name);
+        std::fs::write(file_path, stage_json)?;
+
+        Ok(())
+    }
+
     /// Creates a full file name, given the contract full path, suffix, and extension.
     fn full_file_name(contract_path: &str, suffix: Option<&str>, ir_type: IRType) -> String {
         let mut full_file_name = contract_path.replace('/', "_").replace(':', ".");

crates/llvm-context/src/lib.rs

@@ -27,16 +27,18 @@ pub use self::polkavm::context::function::llvm_runtime::LLVMRuntime as PolkaVMLL
 pub use self::polkavm::context::function::r#return::Return as PolkaVMFunctionReturn;
 pub use self::polkavm::context::function::runtime::deploy_code::DeployCode as PolkaVMDeployCodeFunction;
 pub use self::polkavm::context::function::runtime::entry::Entry as PolkaVMEntryFunction;
+pub use self::polkavm::context::function::runtime::immutable_data_load::ImmutableDataLoad as PolkaVMImmutableDataLoadFunction;
 pub use self::polkavm::context::function::runtime::runtime_code::RuntimeCode as PolkaVMRuntimeCodeFunction;
-pub use self::polkavm::context::function::runtime::Runtime as PolkaVMRuntime;
+pub use self::polkavm::context::function::runtime::FUNCTION_DEPLOY_CODE as PolkaVMFunctionDeployCode;
-pub use self::polkavm::context::function::vyper_data::VyperData as PolkaVMFunctionVyperData;
+pub use self::polkavm::context::function::runtime::FUNCTION_ENTRY as PolkaVMFunctionEntry;
+pub use self::polkavm::context::function::runtime::FUNCTION_LOAD_IMMUTABLE_DATA as PolkaVMFunctionImmutableDataLoad;
+pub use self::polkavm::context::function::runtime::FUNCTION_RUNTIME_CODE as PolkaVMFunctionRuntimeCode;
 pub use self::polkavm::context::function::yul_data::YulData as PolkaVMFunctionYulData;
 pub use self::polkavm::context::function::Function as PolkaVMFunction;
 pub use self::polkavm::context::global::Global as PolkaVMGlobal;
 pub use self::polkavm::context::pointer::Pointer as PolkaVMPointer;
 pub use self::polkavm::context::r#loop::Loop as PolkaVMLoop;
 pub use self::polkavm::context::solidity_data::SolidityData as PolkaVMContextSolidityData;
-pub use self::polkavm::context::vyper_data::VyperData as PolkaVMContextVyperData;
 pub use self::polkavm::context::yul_data::YulData as PolkaVMContextYulData;
 pub use self::polkavm::context::Context as PolkaVMContext;
 pub use self::polkavm::evm::arithmetic as polkavm_evm_arithmetic;

crates/llvm-context/src/optimizer/settings/mod.rs

@@ -21,8 +21,6 @@ pub struct Settings {
 
     /// Fallback to optimizing for size if the bytecode is too large.
     pub is_fallback_to_size_enabled: bool,
-    /// Whether the system request memoization is disabled.
-    pub is_system_request_memoization_disabled: bool,
 
     /// Whether the LLVM `verify each` option is enabled.
     pub is_verify_each_enabled: bool,
@@ -43,7 +41,6 @@ impl Settings {
             level_back_end,
 
             is_fallback_to_size_enabled: false,
-            is_system_request_memoization_disabled: false,
 
             is_verify_each_enabled: false,
             is_debug_logging_enabled: false,
@@ -65,7 +62,6 @@ impl Settings {
             level_back_end,
 
             is_fallback_to_size_enabled: false,
-            is_system_request_memoization_disabled: false,
 
             is_verify_each_enabled,
             is_debug_logging_enabled,
@@ -206,20 +202,10 @@ impl Settings {
         self.is_fallback_to_size_enabled = true;
     }
 
-    /// Disables the system request memoization.
-    pub fn disable_system_request_memoization(&mut self) {
-        self.is_system_request_memoization_disabled = true;
-    }
-
     /// Whether the fallback to optimizing for size is enabled.
     pub fn is_fallback_to_size_enabled(&self) -> bool {
         self.is_fallback_to_size_enabled
     }
-
-    /// Whether the system request memoization is disabled.
-    pub fn is_system_request_memoization_disabled(&self) -> bool {
-        self.is_system_request_memoization_disabled
-    }
 }
 
 impl PartialEq for Settings {

crates/llvm-context/src/polkavm/const/mod.rs

@@ -1,14 +1,8 @@
 //! The LLVM context constants.
 
-/// Runtime API methods.
-pub mod runtime_api;
-
 /// The LLVM framework version.
 pub const LLVM_VERSION: semver::Version = semver::Version::new(18, 1, 4);
 
-/// The PolkaVM version.
-pub const ZKEVM_VERSION: semver::Version = semver::Version::new(1, 3, 2);
-
 /// The register width sized type
 pub static XLEN: usize = revive_common::BIT_LENGTH_X32;
 
@@ -21,63 +15,9 @@ pub static GLOBAL_CALLDATA_POINTER: &str = "ptr_calldata";
 /// The calldata size global variable name.
 pub static GLOBAL_CALLDATA_SIZE: &str = "calldatasize";
 
-/// The return data pointer global variable name.
-pub static GLOBAL_RETURN_DATA_POINTER: &str = "ptr_return_data";
-
-/// The return data size pointer global variable name.
-pub static GLOBAL_RETURN_DATA_SIZE: &str = "returndatasize";
-
 /// The call flags global variable name.
 pub static GLOBAL_CALL_FLAGS: &str = "call_flags";
 
-/// The extra ABI data global variable name.
-pub static GLOBAL_EXTRA_ABI_DATA: &str = "extra_abi_data";
-
-/// The active pointer global variable name.
-pub static GLOBAL_ACTIVE_POINTER: &str = "ptr_active";
-
-/// The constant array global variable name prefix.
-pub static GLOBAL_CONST_ARRAY_PREFIX: &str = "const_array_";
-
-/// The global verbatim getter identifier prefix.
-pub static GLOBAL_VERBATIM_GETTER_PREFIX: &str = "get_global::";
-
-/// The static word size.
-pub static GLOBAL_I256_SIZE: &str = "i256_size";
-
-/// The static value size.
-pub static GLOBAL_I160_SIZE: &str = "i160_size";
-
-/// The static i64 size.
-pub static GLOBAL_I64_SIZE: &str = "i64_size";
-
-/// The external call data offset in the auxiliary heap.
-pub const HEAP_AUX_OFFSET_EXTERNAL_CALL: u64 = 0;
-
-/// The constructor return data offset in the auxiliary heap.
-pub const HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA: u64 =
-    8 * (revive_common::BYTE_LENGTH_WORD as u64);
-
-/// The number of the extra ABI data arguments.
-pub const EXTRA_ABI_DATA_SIZE: usize = 0;
-
-/// The `create` method deployer signature.
-pub static DEPLOYER_SIGNATURE_CREATE: &str = "create(bytes32,bytes32,bytes)";
-
-/// The `create2` method deployer signature.
-pub static DEPLOYER_SIGNATURE_CREATE2: &str = "create2(bytes32,bytes32,bytes)";
-
-/// The absence of system call bit.
-pub const NO_SYSTEM_CALL_BIT: bool = false;
-
-/// The system call bit.
-pub const SYSTEM_CALL_BIT: bool = true;
-
 /// The deployer call header size that consists of:
-/// - selector (4 bytes)
-/// - salt (32 bytes)
 /// - bytecode hash (32 bytes)
-/// - constructor arguments offset (32 bytes)
+pub const DEPLOYER_CALL_HEADER_SIZE: usize = revive_common::BYTE_LENGTH_WORD;
-/// - constructor arguments length (32 bytes)
-pub const DEPLOYER_CALL_HEADER_SIZE: usize =
-    revive_common::BYTE_LENGTH_X32 + (revive_common::BYTE_LENGTH_WORD * 4);

crates/llvm-context/src/polkavm/const/runtime_api.rs

@@ -1,52 +0,0 @@
-//! Runtime API import and export symbols.
-
-/// The contract deploy export.
-pub static CALL: &str = "call";
-
-/// The contract call export.
-pub static DEPLOY: &str = "deploy";
-
-/// All exported symbols.
-/// Useful for configuring common attributes and linkage.
-pub static EXPORTS: [&str; 2] = [CALL, DEPLOY];
-
-pub static ADDRESS: &str = "address";
-
-pub static BLOCK_NUMBER: &str = "block_number";
-
-pub static CALLER: &str = "caller";
-
-pub static DEPOSIT_EVENT: &str = "deposit_event";
-
-pub static GET_STORAGE: &str = "get_storage";
-
-pub static HASH_KECCAK_256: &str = "hash_keccak_256";
-
-pub static INPUT: &str = "input";
-
-pub static NOW: &str = "now";
-
-pub static RETURN: &str = "seal_return";
-
-pub static SET_STORAGE: &str = "set_storage";
-
-pub static VALUE_TRANSFERRED: &str = "value_transferred";
-
-/// All imported runtime API symbols..
-/// Useful for configuring common attributes and linkage.
-pub static IMPORTS: [&str; 11] = [
-    ADDRESS,
-    BLOCK_NUMBER,
-    CALLER,
-    DEPOSIT_EVENT,
-    GET_STORAGE,
-    HASH_KECCAK_256,
-    INPUT,
-    NOW,
-    RETURN,
-    SET_STORAGE,
-    VALUE_TRANSFERRED,
-];
-
-/// PolkaVM __sbrk API symbol to extend the heap memory.
-pub static SBRK: &str = "__sbrk";

crates/llvm-context/src/polkavm/context/address_space.rs

@@ -8,13 +8,7 @@ pub enum AddressSpace {
     Stack,
     /// The heap memory.
     Heap,
-    /// The auxiliary heap memory.
-    HeapAuxiliary,
     /// The generic memory page.
-    Generic,
-    /// The code area.
-    Code,
-    /// The storage.
     Storage,
     /// The transient storage.
     TransientStorage,
@@ -25,9 +19,6 @@ impl From<AddressSpace> for inkwell::AddressSpace {
         match value {
             AddressSpace::Stack => Self::from(0),
             AddressSpace::Heap => Self::from(1),
-            AddressSpace::HeapAuxiliary => Self::from(2),
-            AddressSpace::Generic => Self::from(3),
-            AddressSpace::Code => Self::from(4),
             AddressSpace::Storage => Self::from(5),
             AddressSpace::TransientStorage => Self::from(6),
         }

crates/llvm-context/src/polkavm/context/function/intrinsics.rs

@@ -2,7 +2,6 @@
 
 use inkwell::types::BasicType;
 
-use crate::polkavm::context::address_space::AddressSpace;
 use crate::polkavm::context::function::declaration::Declaration as FunctionDeclaration;
 
 /// The LLVM intrinsic functions, implemented in the LLVM back-end.
@@ -11,10 +10,6 @@ use crate::polkavm::context::function::declaration::Declaration as FunctionDecla
 pub struct Intrinsics<'ctx> {
     /// The trap.
     pub trap: FunctionDeclaration<'ctx>,
-    /// The memory copy within the heap.
-    pub memory_copy: FunctionDeclaration<'ctx>,
-    /// The memory copy from a generic page.
-    pub memory_copy_from_generic: FunctionDeclaration<'ctx>,
     /// Performs endianness swaps on i256 values
     pub byte_swap_word: FunctionDeclaration<'ctx>,
     /// Performs endianness swaps on i160 values
@@ -25,12 +20,6 @@ impl<'ctx> Intrinsics<'ctx> {
     /// The corresponding intrinsic function name.
     pub const FUNCTION_TRAP: &'static str = "llvm.trap";
 
-    /// The corresponding intrinsic function name.
-    pub const FUNCTION_MEMORY_COPY: &'static str = "llvm.memcpy.p1.p1.i256";
-
-    /// The corresponding intrinsic function name.
-    pub const FUNCTION_MEMORY_COPY_FROM_GENERIC: &'static str = "llvm.memcpy.p3.p1.i256";
-
     /// The corresponding intrinsic function name.
     pub const FUNCTION_BYTE_SWAP_WORD: &'static str = "llvm.bswap.i256";
 
@@ -43,12 +32,8 @@ impl<'ctx> Intrinsics<'ctx> {
         module: &inkwell::module::Module<'ctx>,
     ) -> Self {
         let void_type = llvm.void_type();
-        let bool_type = llvm.bool_type();
         let word_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32);
         let address_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_ETH_ADDRESS as u32);
-        let _stack_field_pointer_type = llvm.ptr_type(AddressSpace::Stack.into());
-        let heap_field_pointer_type = llvm.ptr_type(AddressSpace::Heap.into());
-        let generic_byte_pointer_type = llvm.ptr_type(AddressSpace::Generic.into());
 
         let trap = Self::declare(
             llvm,
@@ -56,34 +41,6 @@ impl<'ctx> Intrinsics<'ctx> {
             Self::FUNCTION_TRAP,
             void_type.fn_type(&[], false),
         );
-        let memory_copy = Self::declare(
-            llvm,
-            module,
-            Self::FUNCTION_MEMORY_COPY,
-            void_type.fn_type(
-                &[
-                    heap_field_pointer_type.as_basic_type_enum().into(),
-                    heap_field_pointer_type.as_basic_type_enum().into(),
-                    word_type.as_basic_type_enum().into(),
-                    bool_type.as_basic_type_enum().into(),
-                ],
-                false,
-            ),
-        );
-        let memory_copy_from_generic = Self::declare(
-            llvm,
-            module,
-            Self::FUNCTION_MEMORY_COPY_FROM_GENERIC,
-            void_type.fn_type(
-                &[
-                    heap_field_pointer_type.as_basic_type_enum().into(),
-                    generic_byte_pointer_type.as_basic_type_enum().into(),
-                    word_type.as_basic_type_enum().into(),
-                    bool_type.as_basic_type_enum().into(),
-                ],
-                false,
-            ),
-        );
         let byte_swap_word = Self::declare(
             llvm,
             module,
@@ -99,8 +56,6 @@ impl<'ctx> Intrinsics<'ctx> {
 
         Self {
             trap,
-            memory_copy,
-            memory_copy_from_generic,
             byte_swap_word,
             byte_swap_eth_address,
         }
@@ -130,20 +85,6 @@ impl<'ctx> Intrinsics<'ctx> {
         let word_type = llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32);
 
         match name {
-            name if name == Self::FUNCTION_MEMORY_COPY => vec![
-                llvm.ptr_type(AddressSpace::Heap.into())
-                    .as_basic_type_enum(),
-                llvm.ptr_type(AddressSpace::Heap.into())
-                    .as_basic_type_enum(),
-                word_type.as_basic_type_enum(),
-            ],
-            name if name == Self::FUNCTION_MEMORY_COPY_FROM_GENERIC => vec![
-                llvm.ptr_type(AddressSpace::Heap.into())
-                    .as_basic_type_enum(),
-                llvm.ptr_type(AddressSpace::Generic.into())
-                    .as_basic_type_enum(),
-                word_type.as_basic_type_enum(),
-            ],
             name if name == Self::FUNCTION_BYTE_SWAP_WORD => vec![word_type.as_basic_type_enum()],
             name if name == Self::FUNCTION_BYTE_SWAP_ETH_ADDRESS => {
                 vec![llvm

crates/llvm-context/src/polkavm/context/function/llvm_runtime.rs

@@ -11,20 +11,6 @@ use crate::polkavm::context::function::Function;
 /// The functions are automatically linked to the LLVM implementations if the signatures match.
 #[derive(Debug)]
 pub struct LLVMRuntime<'ctx> {
-    /// The LLVM personality function, used for exception handling.
-    pub personality: FunctionDeclaration<'ctx>,
-    /// The LLVM exception throwing function.
-    pub cxa_throw: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub shl: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub shr: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub sar: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub byte: FunctionDeclaration<'ctx>,
-
     /// The corresponding LLVM runtime function.
     pub add_mod: FunctionDeclaration<'ctx>,
     /// The corresponding LLVM runtime function.
@@ -36,55 +22,9 @@ pub struct LLVMRuntime<'ctx> {
 
     /// The corresponding LLVM runtime function.
     pub sha3: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub system_request: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    //pub far_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub far_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub static_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub static_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub delegate_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub delegate_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub mimic_call: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub mimic_call_byref: FunctionDeclaration<'ctx>,
-
-    /// The corresponding LLVM runtime function.
-    pub r#return: FunctionDeclaration<'ctx>,
-    /// The corresponding LLVM runtime function.
-    pub revert: FunctionDeclaration<'ctx>,
 }
 
 impl<'ctx> LLVMRuntime<'ctx> {
-    /// The LLVM personality function name.
-    pub const FUNCTION_PERSONALITY: &'static str = "__personality";
-
-    /// The LLVM exception throwing function name.
-    pub const FUNCTION_CXA_THROW: &'static str = "__cxa_throw";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SHL: &'static str = "__shl";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SHR: &'static str = "__shr";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SAR: &'static str = "__sar";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_BYTE: &'static str = "__byte";
-
     /// The corresponding runtime function name.
     pub const FUNCTION_ADDMOD: &'static str = "__addmod";
 
@@ -100,145 +40,12 @@ impl<'ctx> LLVMRuntime<'ctx> {
     /// The corresponding runtime function name.
     pub const FUNCTION_SHA3: &'static str = "__sha3";
 
-    /// The corresponding runtime function name.
-    pub const FUNCTION_SYSTEM_REQUEST: &'static str = "__system_request";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_FARCALL: &'static str = "__farcall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_STATICCALL: &'static str = "__staticcall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_DELEGATECALL: &'static str = "__delegatecall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_MIMICCALL: &'static str = "__mimiccall";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_FARCALL_BYREF: &'static str = "__farcall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_STATICCALL_BYREF: &'static str = "__staticcall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_DELEGATECALL_BYREF: &'static str = "__delegatecall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_MIMICCALL_BYREF: &'static str = "__mimiccall_byref";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_RETURN: &'static str = "__return";
-
-    /// The corresponding runtime function name.
-    pub const FUNCTION_REVERT: &'static str = "__revert";
-
     /// A shortcut constructor.
     pub fn new(
         llvm: &'ctx inkwell::context::Context,
         module: &inkwell::module::Module<'ctx>,
         optimizer: &Optimizer,
     ) -> Self {
-        let personality = Self::declare(
-            module,
-            Self::FUNCTION_PERSONALITY,
-            llvm.i32_type().fn_type(&[], false),
-            None,
-        );
-
-        let cxa_throw = Self::declare(
-            module,
-            Self::FUNCTION_CXA_THROW,
-            llvm.void_type().fn_type(
-                vec![
-                    llvm.ptr_type(AddressSpace::Stack.into())
-                        .as_basic_type_enum()
-                        .into();
-                    3
-                ]
-                .as_slice(),
-                false,
-            ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_cxa_throw_attributes(llvm, cxa_throw);
-
-        let shl = Self::declare(
-            module,
-            Self::FUNCTION_SHL,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, shl, optimizer);
-        Function::set_pure_function_attributes(llvm, shl);
-
-        let shr = Self::declare(
-            module,
-            Self::FUNCTION_SHR,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, shr, optimizer);
-        Function::set_pure_function_attributes(llvm, shr);
-
-        let sar = Self::declare(
-            module,
-            Self::FUNCTION_SAR,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, sar, optimizer);
-        Function::set_pure_function_attributes(llvm, sar);
-
-        let byte = Self::declare(
-            module,
-            Self::FUNCTION_BYTE,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into();
-                        2
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, byte, optimizer);
-        Function::set_pure_function_attributes(llvm, byte);
-
         let add_mod =
             Self::define(module, Self::FUNCTION_ADDMOD).expect("should be declared in stdlib");
         Function::set_default_attributes(llvm, add_mod, optimizer);
@@ -288,201 +95,13 @@ impl<'ctx> LLVMRuntime<'ctx> {
             false,
         );
 
-        let system_request = Self::declare(
-            module,
-            Self::FUNCTION_SYSTEM_REQUEST,
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .fn_type(
-                    vec![
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                            .as_basic_type_enum()
-                            .into(),
-                        llvm.ptr_type(AddressSpace::Stack.into())
-                            .as_basic_type_enum()
-                            .into(),
-                    ]
-                    .as_slice(),
-                    false,
-                ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, system_request, optimizer);
-
-        let external_call_arguments: Vec<inkwell::types::BasicMetadataTypeEnum> = vec![
-                llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                    .as_basic_type_enum()
-                    .into();
-                crate::polkavm::context::function::runtime::entry::Entry::MANDATORY_ARGUMENTS_COUNT
-                    + crate::polkavm::EXTRA_ABI_DATA_SIZE
-            ];
-        let mut mimic_call_arguments = external_call_arguments.clone();
-        mimic_call_arguments.push(
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .as_basic_type_enum()
-                .into(),
-        );
-
-        let mut external_call_arguments_by_ref: Vec<inkwell::types::BasicMetadataTypeEnum> = vec![
-            llvm.ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum()
-                .into(),
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .as_basic_type_enum()
-                .into(),
-        ];
-        external_call_arguments_by_ref.extend::<Vec<inkwell::types::BasicMetadataTypeEnum>>(vec![
-            llvm.custom_width_int_type(
-                revive_common::BIT_LENGTH_WORD as u32
-            )
-            .as_basic_type_enum()
-            .into();
-            crate::polkavm::EXTRA_ABI_DATA_SIZE
-        ]);
-        let mut mimic_call_arguments_by_ref = external_call_arguments_by_ref.clone();
-        mimic_call_arguments_by_ref.push(
-            llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                .as_basic_type_enum()
-                .into(),
-        );
-
-        let external_call_result_type = llvm
-            .struct_type(
-                &[
-                    llvm.ptr_type(AddressSpace::Generic.into())
-                        .as_basic_type_enum(),
-                    llvm.bool_type().as_basic_type_enum(),
-                ],
-                false,
-            )
-            .as_basic_type_enum();
-
-        //let far_call = Self::declare(
-        //    module,
-        //    Self::FUNCTION_FARCALL,
-        //    external_call_result_type.fn_type(external_call_arguments.as_slice(), false),
-        //    Some(inkwell::module::Linkage::External),
-        //);
-        //Function::set_default_attributes(llvm, far_call, optimizer);
-        let static_call = Self::declare(
-            module,
-            Self::FUNCTION_STATICCALL,
-            external_call_result_type.fn_type(external_call_arguments.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, static_call, optimizer);
-        let delegate_call = Self::declare(
-            module,
-            Self::FUNCTION_DELEGATECALL,
-            external_call_result_type.fn_type(external_call_arguments.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, delegate_call, optimizer);
-        let mimic_call = Self::declare(
-            module,
-            Self::FUNCTION_MIMICCALL,
-            external_call_result_type.fn_type(mimic_call_arguments.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, mimic_call, optimizer);
-
-        let far_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_FARCALL_BYREF,
-            external_call_result_type.fn_type(external_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, far_call_byref, optimizer);
-        let static_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_STATICCALL_BYREF,
-            external_call_result_type.fn_type(external_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, static_call_byref, optimizer);
-        let delegate_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_DELEGATECALL_BYREF,
-            external_call_result_type.fn_type(external_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, delegate_call_byref, optimizer);
-        let mimic_call_byref = Self::declare(
-            module,
-            Self::FUNCTION_MIMICCALL_BYREF,
-            external_call_result_type.fn_type(mimic_call_arguments_by_ref.as_slice(), false),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, mimic_call_byref, optimizer);
-
-        let r#return = Self::declare(
-            module,
-            Self::FUNCTION_RETURN,
-            llvm.void_type().fn_type(
-                vec![
-                    llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                        .as_basic_type_enum()
-                        .into();
-                    3
-                ]
-                .as_slice(),
-                false,
-            ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, r#return, optimizer);
-        let revert = Self::declare(
-            module,
-            Self::FUNCTION_REVERT,
-            llvm.void_type().fn_type(
-                vec![
-                    llvm.custom_width_int_type(revive_common::BIT_LENGTH_WORD as u32)
-                        .as_basic_type_enum()
-                        .into();
-                    3
-                ]
-                .as_slice(),
-                false,
-            ),
-            Some(inkwell::module::Linkage::External),
-        );
-        Function::set_default_attributes(llvm, revert, optimizer);
-
         Self {
-            personality,
-            cxa_throw,
-
-            shl,
-            shr,
-            sar,
-            byte,
-
             add_mod,
             mul_mod,
             exp,
             sign_extend,
 
             sha3,
-
-            system_request,
-
-            //far_call,
-            static_call,
-            delegate_call,
-            mimic_call,
-
-            far_call_byref,
-            static_call_byref,
-            delegate_call_byref,
-            mimic_call_byref,
-
-            r#return,
-            revert,
         }
     }
 
@@ -506,42 +125,4 @@ impl<'ctx> LLVMRuntime<'ctx> {
         value.set_linkage(inkwell::module::Linkage::External);
         FunctionDeclaration::new(value.get_type(), value).into()
     }
-
-    /// Modifies the external call function with `is_byref` and `is_system` modifiers.
-    pub fn modify(
-        &self,
-        function: FunctionDeclaration<'ctx>,
-        is_byref: bool,
-    ) -> anyhow::Result<FunctionDeclaration<'ctx>> {
-        let modified = if
-        /*function == self.far_call {
-            match is_byref {
-                false => self.far_call,
-                true => self.far_call_byref,
-            }
-        } else if */
-        function == self.static_call {
-            match is_byref {
-                false => self.static_call,
-                true => self.static_call_byref,
-            }
-        } else if function == self.delegate_call {
-            match is_byref {
-                false => self.delegate_call,
-                true => self.delegate_call_byref,
-            }
-        } else if function == self.mimic_call {
-            match is_byref {
-                false => self.mimic_call,
-                true => self.mimic_call_byref,
-            }
-        } else {
-            anyhow::bail!(
-                "Cannot modify an external call function `{}`",
-                function.value.get_name().to_string_lossy()
-            );
-        };
-
-        Ok(modified)
-    }
 }

crates/llvm-context/src/polkavm/context/function/mod.rs

@@ -7,7 +7,6 @@ pub mod intrinsics;
 pub mod llvm_runtime;
 pub mod r#return;
 pub mod runtime;
-pub mod vyper_data;
 pub mod yul_data;
 
 use std::collections::HashMap;
@@ -20,8 +19,6 @@ use crate::polkavm::context::pointer::Pointer;
 use self::declaration::Declaration;
 use self::evmla_data::EVMLAData;
 use self::r#return::Return;
-use self::runtime::Runtime;
-use self::vyper_data::VyperData;
 use self::yul_data::YulData;
 
 /// The LLVM IR generator function.
@@ -48,17 +45,9 @@ pub struct Function<'ctx> {
     yul_data: Option<YulData>,
     /// The EVM legacy assembly compiler data.
     evmla_data: Option<EVMLAData<'ctx>>,
-    /// The Vyper data.
-    vyper_data: Option<VyperData>,
 }
 
 impl<'ctx> Function<'ctx> {
-    /// The near call ABI function prefix.
-    pub const ZKSYNC_NEAR_CALL_ABI_PREFIX: &'static str = "ZKSYNC_NEAR_CALL";
-
-    /// The near call ABI exception handler name.
-    pub const ZKSYNC_NEAR_CALL_ABI_EXCEPTION_HANDLER: &'static str = "ZKSYNC_CATCH_NEAR_CALL";
-
     /// The stack hashmap default capacity.
     const STACK_HASHMAP_INITIAL_CAPACITY: usize = 64;
 
@@ -82,7 +71,6 @@ impl<'ctx> Function<'ctx> {
 
             yul_data: None,
             evmla_data: None,
-            vyper_data: None,
         }
     }
 
@@ -95,15 +83,10 @@ impl<'ctx> Function<'ctx> {
     pub fn is_name_external(name: &str) -> bool {
         name.starts_with("llvm.")
             || (name.starts_with("__")
-                && name != Runtime::FUNCTION_ENTRY
+                && name != self::runtime::FUNCTION_ENTRY
-                && name != Runtime::FUNCTION_DEPLOY_CODE
+                && name != self::runtime::FUNCTION_DEPLOY_CODE
-                && name != Runtime::FUNCTION_RUNTIME_CODE)
+                && name != self::runtime::FUNCTION_RUNTIME_CODE
-    }
+                && name != self::runtime::FUNCTION_LOAD_IMMUTABLE_DATA)
-
-    /// Checks whether the function is related to the near call ABI.
-    pub fn is_near_call_abi(name: &str) -> bool {
-        name.starts_with(Self::ZKSYNC_NEAR_CALL_ABI_PREFIX)
-            || name == Self::ZKSYNC_NEAR_CALL_ABI_EXCEPTION_HANDLER
     }
 
     /// Returns the LLVM function declaration.
@@ -128,7 +111,7 @@ impl<'ctx> Function<'ctx> {
     ) {
         for attribute_kind in attributes.into_iter() {
             match attribute_kind {
-                Attribute::Memory => todo!("`memory` attributes are not yet implemented"),
+                Attribute::Memory => unimplemented!("`memory` attributes are not implemented"),
                 attribute_kind @ Attribute::AlwaysInline if force => {
                     let is_optimize_none_set = declaration
                         .value
@@ -330,29 +313,6 @@ impl<'ctx> Function<'ctx> {
             .expect("The EVM data must have been initialized")
     }
 
-    /// Sets the Vyper data.
-    pub fn set_vyper_data(&mut self, data: VyperData) {
-        self.vyper_data = Some(data);
-    }
-
-    /// Returns the Vyper data reference.
-    /// # Panics
-    /// If the Vyper data has not been initialized.
-    pub fn vyper(&self) -> &VyperData {
-        self.vyper_data
-            .as_ref()
-            .expect("The Vyper data must have been initialized")
-    }
-
-    /// Returns the Vyper data mutable reference.
-    /// # Panics
-    /// If the Vyper data has not been initialized.
-    pub fn vyper_mut(&mut self) -> &mut VyperData {
-        self.vyper_data
-            .as_mut()
-            .expect("The Vyper data must have been initialized")
-    }
-
     /// Sets the Yul data.
     pub fn set_yul_data(&mut self, data: YulData) {
         self.yul_data = Some(data);

crates/llvm-context/src/polkavm/context/function/runtime/default_call.rs

@@ -1,244 +0,0 @@
-//! The `default_call` function.
-
-use inkwell::types::BasicType;
-
-use crate::polkavm::context::function::declaration::Declaration as FunctionDeclaration;
-use crate::polkavm::context::function::llvm_runtime::LLVMRuntime;
-use crate::polkavm::context::function::Function;
-use crate::polkavm::context::Context;
-use crate::polkavm::Dependency;
-use crate::polkavm::WriteLLVM;
-
-/// The `default_call` function.
-/// Generates a default contract call, if the `msg.value` is zero.
-#[derive(Debug)]
-pub struct DefaultCall {
-    /// The name of the inner function used for the low-level call.
-    inner_name: String,
-    /// The function name with the low-level function name as an element.
-    name: String,
-}
-
-#[allow(unused)]
-impl DefaultCall {
-    /// The gas argument index.
-    pub const ARGUMENT_INDEX_GAS: usize = 0;
-
-    /// The address argument index.
-    pub const ARGUMENT_INDEX_ADDRESS: usize = 1;
-
-    /// The input offset argument index.
-    pub const ARGUMENT_INDEX_INPUT_OFFSET: usize = 2;
-
-    /// The input length argument index.
-    pub const ARGUMENT_INDEX_INPUT_LENGTH: usize = 3;
-
-    /// The output offset argument index.
-    pub const ARGUMENT_INDEX_OUTPUT_OFFSET: usize = 4;
-
-    /// The output length argument index.
-    pub const ARGUMENT_INDEX_OUTPUT_LENGTH: usize = 5;
-
-    /// A shortcut constructor.
-    pub fn new(call_function: FunctionDeclaration) -> Self {
-        let inner_name = call_function.value.get_name().to_string_lossy().to_string();
-        let name = Self::name(call_function);
-
-        Self { inner_name, name }
-    }
-
-    /// Returns the function name.
-    pub fn name(call_function: FunctionDeclaration) -> String {
-        let suffix = match call_function.value.get_name().to_string_lossy() {
-            name if name == LLVMRuntime::FUNCTION_FARCALL => "far",
-            name if name == LLVMRuntime::FUNCTION_STATICCALL => "static",
-            name if name == LLVMRuntime::FUNCTION_DELEGATECALL => "delegate",
-            name => panic!("Invalid low-level call inner function `{name}`"),
-        };
-        format!("__default_{suffix}_call")
-    }
-
-    /// Returns the low-level call function.
-    fn inner_function<'ctx, D>(&self, context: &Context<'ctx, D>) -> FunctionDeclaration<'ctx>
-    where
-        D: Dependency + Clone,
-    {
-        match self.inner_name.as_str() {
-            //name if name == LLVMRuntime::FUNCTION_FARCALL => context.llvm_runtime().far_call,
-            name if name == LLVMRuntime::FUNCTION_STATICCALL => context.llvm_runtime().static_call,
-            name if name == LLVMRuntime::FUNCTION_DELEGATECALL => {
-                context.llvm_runtime().delegate_call
-            }
-            name => panic!("Invalid low-level call inner function `{name}`"),
-        }
-    }
-}
-
-impl<D> WriteLLVM<D> for DefaultCall
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type = context.function_type(
-            vec![
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-            ],
-            1,
-            false,
-        );
-        let function = context.add_function(
-            self.name.as_str(),
-            function_type,
-            1,
-            Some(inkwell::module::Linkage::Private),
-        )?;
-        Function::set_frontend_runtime_attributes(
-            context.llvm,
-            function.borrow().declaration(),
-            &context.optimizer,
-        );
-
-        Ok(())
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(self.name.as_str())?;
-
-        /*
-               let gas = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_GAS)
-                   .into_int_value();
-               let address = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_ADDRESS)
-                   .into_int_value();
-               let input_offset = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_INPUT_OFFSET)
-                   .into_int_value();
-               let input_length = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_INPUT_LENGTH)
-                   .into_int_value();
-               let output_offset = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_OUTPUT_OFFSET)
-                   .into_int_value();
-               let output_length = context
-                   .current_function()
-                   .borrow()
-                   .get_nth_param(Self::ARGUMENT_INDEX_OUTPUT_LENGTH)
-                   .into_int_value();
-        */
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        let status_code_result_pointer = context.build_alloca(
-            context.word_type(),
-            "contract_call_result_status_code_pointer",
-        );
-        /*
-        context.build_store(status_code_result_pointer, context.field_const(0));
-
-        let abi_data = crate::polkavm::utils::abi_data(
-            context,
-            input_offset,
-            input_length,
-            Some(gas),
-            AddressSpace::Heap,
-            false,
-        )?
-        .into_int_value();
-
-        let result = context
-            .build_call(
-                self.inner_function(context),
-                crate::polkavm::utils::external_call_arguments(
-                    context,
-                    abi_data.as_basic_value_enum(),
-                    address,
-                    vec![],
-                    None,
-                )
-                .as_slice(),
-                "contract_call_external",
-            )
-            .expect("IntrinsicFunction always returns a flag");
-
-        let result_abi_data = context
-            .builder()
-            .build_extract_value(
-                result.into_struct_value(),
-                0,
-                "contract_call_external_result_abi_data",
-            )
-            .expect("Always exists");
-        let result_abi_data_pointer = Pointer::new(
-            context.byte_type(),
-            AddressSpace::Generic,
-            result_abi_data.into_pointer_value(),
-        );
-        let result_abi_data_casted = result_abi_data_pointer.cast(context.field_type());
-
-        let result_status_code_boolean = context
-            .builder()
-            .build_extract_value(
-                result.into_struct_value(),
-                1,
-                "contract_call_external_result_status_code_boolean",
-            )
-            .expect("Always exists");
-        let result_status_code = context.builder().build_int_z_extend_or_bit_cast(
-            result_status_code_boolean.into_int_value(),
-            context.field_type(),
-            "contract_call_external_result_status_code",
-        )?;
-        context.build_store(status_code_result_pointer, result_status_code);
-
-        let source = result_abi_data_casted;
-
-        let destination = Pointer::new_with_offset(
-            context,
-            AddressSpace::Heap,
-            context.byte_type(),
-            output_offset,
-            "contract_call_destination",
-        );
-
-        context.build_memcpy_return_data(
-            context.intrinsics().memory_copy_from_generic,
-            destination,
-            source,
-            output_length,
-            "contract_call_memcpy_from_child",
-        );
-
-        context.write_abi_pointer(
-            result_abi_data_pointer,
-            crate::polkavm::GLOBAL_RETURN_DATA_POINTER,
-        );
-        context.write_abi_data_size(
-            result_abi_data_pointer,
-            crate::polkavm::GLOBAL_RETURN_DATA_SIZE,
-        );
-        */
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(context.current_function().borrow().return_block());
-        let status_code_result =
-            context.build_load(status_code_result_pointer, "contract_call_status_code")?;
-        context.build_return(Some(&status_code_result));
-
-        Ok(())
-    }
-}

crates/llvm-context/src/polkavm/context/function/runtime/deploy_code.rs

@@ -2,10 +2,8 @@
 
 use std::marker::PhantomData;
 
-use crate::polkavm::context::address_space::AddressSpace;
 use crate::polkavm::context::code_type::CodeType;
-use crate::polkavm::context::function::runtime::Runtime;
+use crate::polkavm::context::function::runtime;
-use crate::polkavm::context::pointer::Pointer;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 use crate::polkavm::WriteLLVM;
@@ -44,10 +42,9 @@ where
     D: Dependency + Clone,
 {
     fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type =
+        let function_type = context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0);
-            context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0, false);
         context.add_function(
-            Runtime::FUNCTION_DEPLOY_CODE,
+            runtime::FUNCTION_DEPLOY_CODE,
             function_type,
             0,
             Some(inkwell::module::Linkage::External),
@@ -57,26 +54,10 @@ where
     }
 
     fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(Runtime::FUNCTION_DEPLOY_CODE)?;
+        context.set_current_function(runtime::FUNCTION_DEPLOY_CODE)?;
 
         context.set_basic_block(context.current_function().borrow().entry_block());
         context.set_code_type(CodeType::Deploy);
-        if let Some(vyper) = context.vyper_data.as_ref() {
-            for index in 0..vyper.immutables_size() / revive_common::BYTE_LENGTH_WORD {
-                let offset = (crate::polkavm::r#const::HEAP_AUX_OFFSET_CONSTRUCTOR_RETURN_DATA
-                    as usize)
-                    + (1 + index) * 2 * revive_common::BYTE_LENGTH_WORD;
-                let value = index * revive_common::BYTE_LENGTH_WORD;
-                let pointer = Pointer::new_with_offset(
-                    context,
-                    AddressSpace::HeapAuxiliary,
-                    context.word_type(),
-                    context.word_const(offset as u64),
-                    "immutable_index_initializer",
-                );
-                context.build_store(pointer, context.word_const(value as u64))?;
-            }
-        }
 
         self.inner.into_llvm(context)?;
         match context

crates/llvm-context/src/polkavm/context/function/runtime/deployer_call.rs

@@ -1,324 +0,0 @@
-//! The `deployer_call` function.
-
-use inkwell::types::BasicType;
-
-use crate::polkavm::context::address_space::AddressSpace;
-use crate::polkavm::context::function::Function;
-use crate::polkavm::context::pointer::Pointer;
-use crate::polkavm::context::Context;
-use crate::polkavm::Dependency;
-use crate::polkavm::WriteLLVM;
-
-/// The `deployer_call` function.
-/// Calls the deployer system contract, which returns the newly deployed contract address or 0.
-/// The address is returned in the first 32-byte word of the return data. If it is 0, the 0 is
-/// returned. If the entire call has failed, there is also a 0 returned.
-#[derive(Debug)]
-pub struct DeployerCall {
-    /// The address space where the calldata is allocated.
-    /// Solidity uses the ordinary heap. Vyper uses the auxiliary heap.
-    address_space: AddressSpace,
-}
-
-impl DeployerCall {
-    /// The default function name.
-    pub const FUNCTION_NAME: &'static str = "__deployer_call";
-
-    /// The value argument index.
-    pub const ARGUMENT_INDEX_VALUE: usize = 0;
-
-    /// The input offset argument index.
-    pub const ARGUMENT_INDEX_INPUT_OFFSET: usize = 1;
-
-    /// The input length argument index.
-    pub const ARGUMENT_INDEX_INPUT_LENGTH: usize = 2;
-
-    /// The signature hash argument index.
-    pub const ARGUMENT_INDEX_SIGNATURE_HASH: usize = 3;
-
-    /// The salt argument index.
-    pub const ARGUMENT_INDEX_SALT: usize = 4;
-
-    /// A shortcut constructor.
-    pub fn new(address_space: AddressSpace) -> Self {
-        Self { address_space }
-    }
-}
-
-impl<D> WriteLLVM<D> for DeployerCall
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type = context.function_type(
-            vec![
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-                context.word_type().as_basic_type_enum(),
-            ],
-            1,
-            false,
-        );
-        let function = context.add_function(
-            Self::FUNCTION_NAME,
-            function_type,
-            1,
-            Some(inkwell::module::Linkage::External),
-        )?;
-        Function::set_frontend_runtime_attributes(
-            context.llvm,
-            function.borrow().declaration(),
-            &context.optimizer,
-        );
-
-        Ok(())
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(Self::FUNCTION_NAME)?;
-
-        let value = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_VALUE)
-            .into_int_value();
-        let input_offset = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_INPUT_OFFSET)
-            .into_int_value();
-        let input_length = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_INPUT_LENGTH)
-            .into_int_value();
-        let signature_hash = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_SIGNATURE_HASH)
-            .into_int_value();
-        let salt = context
-            .current_function()
-            .borrow()
-            .get_nth_param(Self::ARGUMENT_INDEX_SALT)
-            .into_int_value();
-
-        let error_block = context.append_basic_block("deployer_call_error_block");
-        let success_block = context.append_basic_block("deployer_call_success_block");
-        let value_zero_block = context.append_basic_block("deployer_call_value_zero_block");
-        let value_non_zero_block = context.append_basic_block("deployer_call_value_non_zero_block");
-        let value_join_block = context.append_basic_block("deployer_call_value_join_block");
-
-        context.set_basic_block(context.current_function().borrow().entry_block());
-        let _abi_data = crate::polkavm::utils::abi_data(
-            context,
-            input_offset,
-            input_length,
-            None,
-            self.address_space,
-            true,
-        )?;
-
-        let signature_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.word_type(),
-            input_offset,
-            "deployer_call_signature_pointer",
-        );
-        context.build_store(signature_pointer, signature_hash)?;
-
-        let salt_offset = context.builder().build_int_add(
-            input_offset,
-            context.word_const(revive_common::BYTE_LENGTH_X32 as u64),
-            "deployer_call_salt_offset",
-        )?;
-        let salt_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.word_type(),
-            salt_offset,
-            "deployer_call_salt_pointer",
-        );
-        context.build_store(salt_pointer, salt)?;
-
-        let arguments_offset_offset = context.builder().build_int_add(
-            salt_offset,
-            context.word_const((revive_common::BYTE_LENGTH_WORD * 2) as u64),
-            "deployer_call_arguments_offset_offset",
-        )?;
-        let arguments_offset_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.word_type(),
-            arguments_offset_offset,
-            "deployer_call_arguments_offset_pointer",
-        );
-        context.build_store(
-            arguments_offset_pointer,
-            context.word_const(
-                (crate::polkavm::DEPLOYER_CALL_HEADER_SIZE
-                    - (revive_common::BYTE_LENGTH_X32 + revive_common::BYTE_LENGTH_WORD))
-                    as u64,
-            ),
-        )?;
-
-        let arguments_length_offset = context.builder().build_int_add(
-            arguments_offset_offset,
-            context.word_const(revive_common::BYTE_LENGTH_WORD as u64),
-            "deployer_call_arguments_length_offset",
-        )?;
-        let arguments_length_pointer = Pointer::new_with_offset(
-            context,
-            self.address_space,
-            context.word_type(),
-            arguments_length_offset,
-            "deployer_call_arguments_length_pointer",
-        );
-        let arguments_length_value = context.builder().build_int_sub(
-            input_length,
-            context.word_const(crate::polkavm::DEPLOYER_CALL_HEADER_SIZE as u64),
-            "deployer_call_arguments_length",
-        )?;
-        context.build_store(arguments_length_pointer, arguments_length_value)?;
-
-        let result_pointer =
-            context.build_alloca(context.word_type(), "deployer_call_result_pointer");
-        context.build_store(result_pointer, context.word_const(0))?;
-        let deployer_call_result_type = context.structure_type(&[
-            context
-                .llvm()
-                .ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum(),
-            context.bool_type().as_basic_type_enum(),
-        ]);
-        let deployer_call_result_pointer =
-            context.build_alloca(deployer_call_result_type, "deployer_call_result_pointer");
-        context.build_store(
-            deployer_call_result_pointer,
-            deployer_call_result_type.const_zero(),
-        )?;
-        let is_value_zero = context.builder().build_int_compare(
-            inkwell::IntPredicate::EQ,
-            value,
-            context.word_const(0),
-            "deployer_call_is_value_zero",
-        )?;
-        context.build_conditional_branch(is_value_zero, value_zero_block, value_non_zero_block)?;
-
-        context.set_basic_block(value_zero_block);
-        //let deployer_call_result = context
-        //    .build_call(
-        //        context.llvm_runtime().far_call,
-        //        crate::polkavm::utils::external_call_arguments(
-        //            context,
-        //            abi_data,
-        //            context.field_const(zkevm_opcode_defs::ADDRESS_CONTRACT_DEPLOYER.into()),
-        //            vec![],
-        //            None,
-        //        )
-        //        .as_slice(),
-        //        "deployer_call_ordinary",
-        //    )
-        //    .expect("Always returns a value");
-        //context.build_store(deployer_call_result_pointer, deployer_call_result)?;
-        context.build_unconditional_branch(value_join_block);
-
-        context.set_basic_block(value_non_zero_block);
-        //let deployer_call_result = context
-        //    .build_call(
-        //        context.llvm_runtime().far_call,
-        //        crate::polkavm::utils::external_call_arguments(
-        //            context,
-        //            abi_data.as_basic_value_enum(),
-        //            context.field_const(zkevm_opcode_defs::ADDRESS_MSG_VALUE.into()),
-        //            vec![
-        //                value,
-        //                context.field_const(zkevm_opcode_defs::ADDRESS_CONTRACT_DEPLOYER.into()),
-        //                context.field_const(u64::from(crate::polkavm::r#const::SYSTEM_CALL_BIT)),
-        //            ],
-        //            None,
-        //        )
-        //        .as_slice(),
-        //        "deployer_call_system",
-        //    )
-        //    .expect("Always returns a value");
-        //context.build_store(deployer_call_result_pointer, deployer_call_result)?;
-        context.build_unconditional_branch(value_join_block);
-
-        context.set_basic_block(value_join_block);
-        let result_abi_data_pointer = context.build_gep(
-            deployer_call_result_pointer,
-            &[
-                context.word_const(0),
-                context
-                    .integer_type(revive_common::BIT_LENGTH_X32)
-                    .const_zero(),
-            ],
-            context
-                .llvm()
-                .ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum(),
-            "deployer_call_result_abi_data_pointer",
-        );
-        let result_abi_data =
-            context.build_load(result_abi_data_pointer, "deployer_call_result_abi_data")?;
-
-        let result_status_code_pointer = context.build_gep(
-            deployer_call_result_pointer,
-            &[
-                context.word_const(0),
-                context
-                    .integer_type(revive_common::BIT_LENGTH_X32)
-                    .const_int(1, false),
-            ],
-            context.bool_type().as_basic_type_enum(),
-            "contract_call_external_result_status_code_pointer",
-        );
-        let result_status_code_boolean = context
-            .build_load(
-                result_status_code_pointer,
-                "contract_call_external_result_status_code_boolean",
-            )?
-            .into_int_value();
-
-        context.build_conditional_branch(result_status_code_boolean, success_block, error_block)?;
-
-        context.set_basic_block(success_block);
-        let result_abi_data_pointer = Pointer::new(
-            context.word_type(),
-            AddressSpace::Generic,
-            result_abi_data.into_pointer_value(),
-        );
-        let address_or_status_code = context.build_load(
-            result_abi_data_pointer,
-            "deployer_call_address_or_status_code",
-        )?;
-        context.build_store(result_pointer, address_or_status_code)?;
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(error_block);
-        let result_abi_data_pointer = Pointer::new(
-            context.byte_type(),
-            AddressSpace::Generic,
-            result_abi_data.into_pointer_value(),
-        );
-        context.write_abi_pointer(
-            result_abi_data_pointer,
-            crate::polkavm::GLOBAL_RETURN_DATA_POINTER,
-        );
-        context.write_abi_data_size(
-            result_abi_data_pointer,
-            crate::polkavm::GLOBAL_RETURN_DATA_SIZE,
-        );
-        context.build_unconditional_branch(context.current_function().borrow().return_block());
-
-        context.set_basic_block(context.current_function().borrow().return_block());
-        let result = context.build_load(result_pointer, "deployer_call_result")?;
-        context.build_return(Some(&result));
-
-        Ok(())
-    }
-}

crates/llvm-context/src/polkavm/context/function/runtime/entry.rs

@@ -3,12 +3,10 @@
 use inkwell::types::BasicType;
 
 use crate::polkavm::context::address_space::AddressSpace;
-use crate::polkavm::context::function::runtime::Runtime;
+use crate::polkavm::context::function::runtime;
 use crate::polkavm::context::Context;
-use crate::polkavm::r#const::*;
 use crate::polkavm::Dependency;
 use crate::polkavm::WriteLLVM;
-use crate::PolkaVMPointer as Pointer;
 
 /// The entry function.
 /// The function is a wrapper managing the runtime and deploy code calling logic.
@@ -20,9 +18,6 @@ impl Entry {
     /// The call flags argument index.
     pub const ARGUMENT_INDEX_CALL_FLAGS: usize = 0;
 
-    /// The number of mandatory arguments.
-    pub const MANDATORY_ARGUMENTS_COUNT: usize = 2;
-
     /// Reserve 1kb for calldata.
     pub const MAX_CALLDATA_SIZE: usize = 1024;
 
@@ -32,6 +27,18 @@ impl Entry {
     where
         D: Dependency + Clone,
     {
+        context.declare_global(
+            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER,
+            context.word_type().array_type(0),
+            AddressSpace::Stack,
+        );
+
+        context.declare_global(
+            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE,
+            context.xlen_type(),
+            AddressSpace::Stack,
+        );
+
         let calldata_type = context.array_type(context.byte_type(), Self::MAX_CALLDATA_SIZE);
         context.set_global(
             crate::polkavm::GLOBAL_CALLDATA_POINTER,
@@ -42,7 +49,7 @@ impl Entry {
 
         context.set_global(
             crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER,
-            context.llvm().ptr_type(AddressSpace::Generic.into()),
+            context.llvm().ptr_type(AddressSpace::Heap.into()),
             AddressSpace::Stack,
             context.xlen_type().get_undef(),
         );
@@ -50,7 +57,10 @@ impl Entry {
             context
                 .get_global(crate::polkavm::GLOBAL_HEAP_MEMORY_POINTER)?
                 .into(),
-            context.build_sbrk(context.integer_const(crate::polkavm::XLEN, 0))?,
+            context.build_sbrk(
+                context.xlen_type().const_zero(),
+                context.xlen_type().const_zero(),
+            )?,
         )?;
 
         context.set_global(
@@ -59,12 +69,6 @@ impl Entry {
             AddressSpace::Stack,
             context.word_undef(),
         );
-        context.set_global(
-            crate::polkavm::GLOBAL_RETURN_DATA_SIZE,
-            context.word_type(),
-            AddressSpace::Stack,
-            context.word_const(0),
-        );
 
         context.set_global(
             crate::polkavm::GLOBAL_CALL_FLAGS,
@@ -73,44 +77,6 @@ impl Entry {
             context.word_const(0),
         );
 
-        let extra_abi_data_type = context.array_type(
-            context.word_type().as_basic_type_enum(),
-            crate::polkavm::EXTRA_ABI_DATA_SIZE,
-        );
-        context.set_global(
-            crate::polkavm::GLOBAL_EXTRA_ABI_DATA,
-            extra_abi_data_type,
-            AddressSpace::Stack,
-            extra_abi_data_type.const_zero(),
-        );
-
-        context.set_global(
-            crate::polkavm::GLOBAL_I256_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.integer_const(
-                crate::polkavm::XLEN,
-                revive_common::BYTE_LENGTH_X64 as u64 * 4,
-            ),
-        );
-
-        context.set_global(
-            crate::polkavm::GLOBAL_I160_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.integer_const(
-                crate::polkavm::XLEN,
-                revive_common::BYTE_LENGTH_X64 as u64 * 2 + revive_common::BYTE_LENGTH_X32 as u64,
-            ),
-        );
-
-        context.set_global(
-            crate::polkavm::GLOBAL_I64_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-            context.integer_const(crate::polkavm::XLEN, revive_common::BYTE_LENGTH_X64 as u64),
-        );
-
         Ok(())
     }
 
@@ -130,7 +96,7 @@ impl Entry {
             "input_pointer_casted",
         )?;
 
-        let length_pointer = context.build_alloca(context.xlen_type(), "len_ptr");
+        let length_pointer = context.build_alloca_at_entry(context.xlen_type(), "len_ptr");
         let length_pointer_casted = context.builder.build_ptr_to_int(
             length_pointer.value,
             context.xlen_type(),
@@ -142,7 +108,7 @@ impl Entry {
             context.integer_const(crate::polkavm::XLEN, Self::MAX_CALLDATA_SIZE as u64),
         )?;
         context.build_runtime_call(
-            runtime_api::INPUT,
+            revive_runtime_api::polkavm_imports::INPUT,
             &[input_pointer_casted.into(), length_pointer_casted.into()],
         );
 
@@ -162,27 +128,6 @@ impl Entry {
             calldata_size_casted,
         );
 
-        // Store calldata end pointer
-        let input_pointer = Pointer::new(
-            input_pointer.get_type(),
-            AddressSpace::Generic,
-            input_pointer,
-        );
-        let calldata_end_pointer = context.build_gep(
-            input_pointer,
-            &[calldata_size_casted],
-            context
-                .llvm()
-                .ptr_type(AddressSpace::Generic.into())
-                .as_basic_type_enum(),
-            "return_data_abi_initializer",
-        );
-        context.write_abi_pointer(
-            calldata_end_pointer,
-            crate::polkavm::GLOBAL_RETURN_DATA_POINTER,
-        );
-        context.write_abi_pointer(calldata_end_pointer, crate::polkavm::GLOBAL_ACTIVE_POINTER);
-
         Ok(())
     }
 
@@ -215,21 +160,21 @@ impl Entry {
 
         let deploy_code = context
             .functions
-            .get(Runtime::FUNCTION_DEPLOY_CODE)
+            .get(runtime::FUNCTION_DEPLOY_CODE)
             .cloned()
             .ok_or_else(|| anyhow::anyhow!("Contract deploy code not found"))?;
         let runtime_code = context
             .functions
-            .get(Runtime::FUNCTION_RUNTIME_CODE)
+            .get(runtime::FUNCTION_RUNTIME_CODE)
             .cloned()
             .ok_or_else(|| anyhow::anyhow!("Contract runtime code not found"))?;
 
         context.set_basic_block(deploy_code_call_block);
-        context.build_invoke(deploy_code.borrow().declaration, &[], "deploy_code_call");
+        context.build_call(deploy_code.borrow().declaration, &[], "deploy_code_call");
         context.build_unconditional_branch(context.current_function().borrow().return_block());
 
         context.set_basic_block(runtime_code_call_block);
-        context.build_invoke(runtime_code.borrow().declaration, &[], "runtime_code_call");
+        context.build_call(runtime_code.borrow().declaration, &[], "runtime_code_call");
         context.build_unconditional_branch(context.current_function().borrow().return_block());
 
         Ok(())
@@ -242,12 +187,13 @@ where
 {
     fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
         let entry_arguments = vec![context.bool_type().as_basic_type_enum()];
-        let entry_function_type = context.function_type(entry_arguments, 0, false);
+        let entry_function_type = context.function_type(entry_arguments, 0);
-        context.add_function(Runtime::FUNCTION_ENTRY, entry_function_type, 0, None)?;
+        context.add_function(
-
+            runtime::FUNCTION_ENTRY,
-        for symbol in runtime_api::EXPORTS {
+            entry_function_type,
-            context.declare_extern_function(symbol)?;
+            0,
-        }
+            Some(inkwell::module::Linkage::External),
+        )?;
 
         Ok(())
     }
@@ -257,7 +203,7 @@ where
     /// The `entry` function loads calldata, sets globals and calls the runtime or deploy code.
     fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
         let entry = context
-            .get_function(Runtime::FUNCTION_ENTRY)
+            .get_function(runtime::FUNCTION_ENTRY)
             .expect("the entry function should already be declared")
             .borrow()
             .declaration;
@@ -268,27 +214,7 @@ where
             true,
         );
 
-        context.set_current_function(runtime_api::DEPLOY)?;
+        context.set_current_function(runtime::FUNCTION_ENTRY)?;
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        assert!(context
-            .build_call(entry, &[context.bool_const(true).into()], "entry_deploy")
-            .is_none());
-
-        context.set_basic_block(context.current_function().borrow().return_block);
-        context.build_unreachable();
-
-        context.set_current_function(runtime_api::CALL)?;
-        context.set_basic_block(context.current_function().borrow().entry_block());
-
-        assert!(context
-            .build_call(entry, &[context.bool_const(false).into()], "entry_call")
-            .is_none());
-
-        context.set_basic_block(context.current_function().borrow().return_block);
-        context.build_unreachable();
-
-        context.set_current_function(Runtime::FUNCTION_ENTRY)?;
         context.set_basic_block(context.current_function().borrow().entry_block());
 
         Self::initialize_globals(context)?;

crates/llvm-context/src/polkavm/context/function/runtime/immutable_data_load.rs

@@ -0,0 +1,116 @@
+//! The immutable data runtime function.
+
+use crate::polkavm::context::address_space::AddressSpace;
+use crate::polkavm::context::function::runtime;
+use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+use crate::polkavm::WriteLLVM;
+
+/// A function for requesting the immutable data from the runtime.
+/// This is a special function that is only used by the front-end generated code.
+///
+/// The runtime API is called lazily and subsequent calls are no-ops.
+///
+/// The bytes written is asserted to match the expected length.
+/// This should never fail; the length is known.
+/// However, this is a one time assertion, hence worth it.
+#[derive(Debug)]
+pub struct ImmutableDataLoad;
+
+impl<D> WriteLLVM<D> for ImmutableDataLoad
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        context.add_function(
+            runtime::FUNCTION_LOAD_IMMUTABLE_DATA,
+            context.void_type().fn_type(Default::default(), false),
+            0,
+            Some(inkwell::module::Linkage::Private),
+        )?;
+
+        Ok(())
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        context.set_current_function(runtime::FUNCTION_LOAD_IMMUTABLE_DATA)?;
+        context.set_basic_block(context.current_function().borrow().entry_block());
+
+        let immutable_data_size_pointer = context
+            .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE)?
+            .value
+            .as_pointer_value();
+        let immutable_data_size = context.build_load(
+            Pointer::new(
+                context.xlen_type(),
+                AddressSpace::Stack,
+                immutable_data_size_pointer,
+            ),
+            "immutable_data_size_load",
+        )?;
+
+        let load_immutable_data_block = context.append_basic_block("load_immutables_block");
+        let return_block = context.current_function().borrow().return_block();
+        let immutable_data_size_is_zero = context.builder().build_int_compare(
+            inkwell::IntPredicate::EQ,
+            context.xlen_type().const_zero(),
+            immutable_data_size.into_int_value(),
+            "immutable_data_size_is_zero",
+        )?;
+        context.build_conditional_branch(
+            immutable_data_size_is_zero,
+            return_block,
+            load_immutable_data_block,
+        )?;
+
+        context.set_basic_block(load_immutable_data_block);
+        let output_pointer = context
+            .get_global(revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER)?
+            .value
+            .as_pointer_value();
+        context.build_runtime_call(
+            revive_runtime_api::polkavm_imports::GET_IMMUTABLE_DATA,
+            &[
+                context
+                    .builder()
+                    .build_ptr_to_int(output_pointer, context.xlen_type(), "ptr_to_xlen")?
+                    .into(),
+                context
+                    .builder()
+                    .build_ptr_to_int(
+                        immutable_data_size_pointer,
+                        context.xlen_type(),
+                        "ptr_to_xlen",
+                    )?
+                    .into(),
+            ],
+        );
+        let bytes_written = context.builder().build_load(
+            context.xlen_type(),
+            immutable_data_size_pointer,
+            "bytes_written",
+        )?;
+        context.builder().build_store(
+            immutable_data_size_pointer,
+            context.xlen_type().const_zero(),
+        )?;
+        let overflow_block = context.append_basic_block("immutable_data_overflow");
+        let is_overflow = context.builder().build_int_compare(
+            inkwell::IntPredicate::UGT,
+            immutable_data_size.into_int_value(),
+            bytes_written.into_int_value(),
+            "is_overflow",
+        )?;
+        context.build_conditional_branch(is_overflow, overflow_block, return_block)?;
+
+        context.set_basic_block(overflow_block);
+        context.build_call(context.intrinsics().trap, &[], "invalid_trap");
+        context.build_unreachable();
+
+        context.set_basic_block(return_block);
+        context.build_return(None);
+
+        Ok(())
+    }
+}

crates/llvm-context/src/polkavm/context/function/runtime/mod.rs

@@ -1,90 +1,18 @@
 //! The front-end runtime functions.
 
-pub mod default_call;
 pub mod deploy_code;
-pub mod deployer_call;
 pub mod entry;
+pub mod immutable_data_load;
 pub mod runtime_code;
 
-use crate::polkavm::context::address_space::AddressSpace;
+/// The main entry function name.
-use crate::polkavm::context::function::declaration::Declaration as FunctionDeclaration;
+pub const FUNCTION_ENTRY: &str = "__entry";
-use crate::polkavm::context::Context;
-use crate::polkavm::Dependency;
-use crate::polkavm::WriteLLVM;
 
-use self::default_call::DefaultCall;
+/// The deploy code function name.
-use self::deployer_call::DeployerCall;
+pub const FUNCTION_DEPLOY_CODE: &str = "__deploy";
 
-/// The front-end runtime functions.
+/// The runtime code function name.
-#[derive(Debug, Clone)]
+pub const FUNCTION_RUNTIME_CODE: &str = "__runtime";
-pub struct Runtime {
-    /// The address space where the calldata is allocated.
-    /// Solidity uses the ordinary heap. Vyper uses the auxiliary heap.
-    address_space: AddressSpace,
-}
 
-impl Runtime {
+/// The immutable data load function name.
-    /// The main entry function name.
+pub const FUNCTION_LOAD_IMMUTABLE_DATA: &str = "__immutable_data_load";
-    pub const FUNCTION_ENTRY: &'static str = "__entry";
-
-    /// The deploy code function name.
-    pub const FUNCTION_DEPLOY_CODE: &'static str = "__deploy";
-
-    /// The runtime code function name.
-    pub const FUNCTION_RUNTIME_CODE: &'static str = "__runtime";
-
-    /// A shortcut constructor.
-    pub fn new(address_space: AddressSpace) -> Self {
-        Self { address_space }
-    }
-
-    /// Returns the corresponding runtime function.
-    pub fn default_call<'ctx, D>(
-        context: &Context<'ctx, D>,
-        call_function: FunctionDeclaration<'ctx>,
-    ) -> FunctionDeclaration<'ctx>
-    where
-        D: Dependency + Clone,
-    {
-        context
-            .get_function(DefaultCall::name(call_function).as_str())
-            .expect("Always exists")
-            .borrow()
-            .declaration()
-    }
-
-    /// Returns the corresponding runtime function.
-    pub fn deployer_call<'ctx, D>(context: &Context<'ctx, D>) -> FunctionDeclaration<'ctx>
-    where
-        D: Dependency + Clone,
-    {
-        context
-            .get_function(DeployerCall::FUNCTION_NAME)
-            .expect("Always exists")
-            .borrow()
-            .declaration()
-    }
-}
-
-impl<D> WriteLLVM<D> for Runtime
-where
-    D: Dependency + Clone,
-{
-    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        //DefaultCall::new(context.llvm_runtime().far_call).declare(context)?;
-        DefaultCall::new(context.llvm_runtime().static_call).declare(context)?;
-        DefaultCall::new(context.llvm_runtime().delegate_call).declare(context)?;
-        DeployerCall::new(self.address_space).declare(context)?;
-
-        Ok(())
-    }
-
-    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        //DefaultCall::new(context.llvm_runtime().far_call).into_llvm(context)?;
-        DefaultCall::new(context.llvm_runtime().static_call).into_llvm(context)?;
-        DefaultCall::new(context.llvm_runtime().delegate_call).into_llvm(context)?;
-        DeployerCall::new(self.address_space).into_llvm(context)?;
-
-        Ok(())
-    }
-}

crates/llvm-context/src/polkavm/context/function/runtime/runtime_code.rs

@@ -3,7 +3,7 @@
 use std::marker::PhantomData;
 
 use crate::polkavm::context::code_type::CodeType;
-use crate::polkavm::context::function::runtime::Runtime;
+use crate::polkavm::context::function::runtime;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 use crate::polkavm::WriteLLVM;
@@ -42,10 +42,9 @@ where
     D: Dependency + Clone,
 {
     fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
-        let function_type =
+        let function_type = context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0);
-            context.function_type::<inkwell::types::BasicTypeEnum>(vec![], 0, false);
         context.add_function(
-            Runtime::FUNCTION_RUNTIME_CODE,
+            runtime::FUNCTION_RUNTIME_CODE,
             function_type,
             0,
             Some(inkwell::module::Linkage::External),
@@ -55,7 +54,7 @@ where
     }
 
     fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
-        context.set_current_function(Runtime::FUNCTION_RUNTIME_CODE)?;
+        context.set_current_function(runtime::FUNCTION_RUNTIME_CODE)?;
 
         context.set_basic_block(context.current_function().borrow().entry_block());
         context.set_code_type(CodeType::Runtime);

crates/llvm-context/src/polkavm/context/function/vyper_data.rs

@@ -1,41 +0,0 @@
-//! The LLVM function Vyper data.
-
-use std::collections::HashMap;
-
-/// The LLVM function Vyper data.
-/// Describes some data that is only relevant to Vyper.
-#[derive(Debug)]
-pub struct VyperData {
-    /// The block-local variables. They are still allocated at the beginning of the function,
-    /// but their parent block must be known in order to pass the implicit arguments thereto.
-    /// Is only used by the Vyper LLL IR compiler.
-    label_arguments: HashMap<String, Vec<String>>,
-}
-
-impl Default for VyperData {
-    fn default() -> Self {
-        Self {
-            label_arguments: HashMap::with_capacity(Self::LABEL_ARGUMENTS_HASHMAP_INITIAL_CAPACITY),
-        }
-    }
-}
-
-impl VyperData {
-    /// The label arguments hashmap default capacity.
-    const LABEL_ARGUMENTS_HASHMAP_INITIAL_CAPACITY: usize = 16;
-
-    /// A shortcut constructor.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Returns the list of a Vyper label arguments.
-    pub fn label_arguments(&self, label_name: &str) -> Option<Vec<String>> {
-        self.label_arguments.get(label_name).cloned()
-    }
-
-    /// Inserts arguments for the specified label.
-    pub fn insert_label_arguments(&mut self, label_name: String, arguments: Vec<String>) {
-        self.label_arguments.insert(label_name, arguments);
-    }
-}

crates/llvm-context/src/polkavm/context/global.rs

@@ -42,9 +42,6 @@ impl<'ctx> Global<'ctx> {
             .value
             .set_visibility(inkwell::GlobalVisibility::Default);
         global.value.set_externally_initialized(false);
-        if let AddressSpace::Code = address_space {
-            global.value.set_constant(true);
-        }
         if !r#type.is_pointer_type() {
             global.value.set_initializer(&initializer);
         } else {
@@ -54,4 +51,31 @@ impl<'ctx> Global<'ctx> {
 
         global
     }
+
+    /// Construct an external global.
+    pub fn declare<D, T>(
+        context: &mut Context<'ctx, D>,
+        r#type: T,
+        address_space: AddressSpace,
+        name: &str,
+    ) -> Self
+    where
+        D: PolkaVMDependency + Clone,
+        T: BasicType<'ctx>,
+    {
+        let r#type = r#type.as_basic_type_enum();
+
+        let value = context
+            .module()
+            .add_global(r#type, Some(address_space.into()), name);
+        let global = Self { r#type, value };
+
+        global.value.set_linkage(inkwell::module::Linkage::External);
+        global
+            .value
+            .set_visibility(inkwell::GlobalVisibility::Default);
+        global.value.set_externally_initialized(true);
+
+        global
+    }
 }

crates/llvm-context/src/polkavm/context/solidity_data.rs

@@ -17,7 +17,7 @@ impl SolidityData {
         Self::default()
     }
 
-    /// Returns the current number of immutables values in the contract.
+    /// Returns the current size of immutable values in the contract.
     pub fn immutables_size(&self) -> usize {
         self.immutables.len() * revive_common::BYTE_LENGTH_WORD
     }

crates/llvm-context/src/polkavm/context/vyper_data.rs

@@ -1,37 +0,0 @@
-//! The LLVM IR generator Vyper data.
-
-/// The LLVM IR generator Vyper data.
-/// Describes some data that is only relevant to Vyper.
-#[derive(Debug)]
-pub struct VyperData {
-    /// The immutables size tracker. Stores the size in bytes.
-    /// Does not take into account the size of the indexes.
-    immutables_size: usize,
-    /// Whether the contract forwarder has been used.
-    is_forwarder_used: bool,
-}
-
-impl VyperData {
-    /// A shortcut constructor.
-    pub fn new(immutables_size: usize, is_forwarder_used: bool) -> Self {
-        Self {
-            immutables_size,
-            is_forwarder_used,
-        }
-    }
-
-    /// Returns the size of the immutables data of the contract.
-    pub fn immutables_size(&self) -> usize {
-        self.immutables_size
-    }
-
-    /// Sets the forwarder usage flag.
-    pub fn set_is_forwarder_used(&mut self) {
-        self.is_forwarder_used = true;
-    }
-
-    /// Returns the forwarder usage flag.
-    pub fn is_forwarder_used(&self) -> bool {
-        self.is_forwarder_used
-    }
-}

crates/llvm-context/src/polkavm/context/yul_data.rs

@@ -8,28 +8,12 @@ use num::Zero;
 /// Describes some data that is only relevant to Yul.
 #[derive(Debug, Default)]
 pub struct YulData {
-    /// The system mode flag.
-    /// The call simulations only work if this mode is enabled.
-    is_system_mode: bool,
     /// The list of constant arrays in the code section.
     /// It is a temporary storage used until the finalization method is called.
     const_arrays: BTreeMap<u8, Vec<num::BigUint>>,
 }
 
 impl YulData {
-    /// A shortcut constructor.
-    pub fn new(is_system_mode: bool) -> Self {
-        Self {
-            is_system_mode,
-            const_arrays: BTreeMap::new(),
-        }
-    }
-
-    /// Whether the system mode is enabled.
-    pub fn is_system_mode(&self) -> bool {
-        self.is_system_mode
-    }
-
     /// Declares a temporary constant array representation.
     pub fn const_array_declare(&mut self, index: u8, size: u16) -> anyhow::Result<()> {
         if self.const_arrays.contains_key(&index) {