init

2026-06-14 18:01:05 +00:00 · 2025-03-21 10:11:32 +01:00
328 changed files with 1 additions and 47649 deletions
@@ -1,17 +0,0 @@
 [target.wasm32-unknown-emscripten]
 rustflags = [
    "-Clink-arg=-sEXPORTED_FUNCTIONS=_main,_free,_malloc",
    "-Clink-arg=-sNO_INVOKE_RUN=1",
    "-Clink-arg=-sEXIT_RUNTIME=1",
    "-Clink-arg=-sALLOW_MEMORY_GROWTH=1",
    "-Clink-arg=-sEXPORTED_RUNTIME_METHODS=FS,callMain,stringToNewUTF8",
    "-Clink-arg=-sMODULARIZE=1",
    "-Clink-arg=-sEXPORT_NAME=createRevive",
    "-Clink-arg=-sWASM_ASYNC_COMPILATION=0",
    "-Clink-arg=-sDYNAMIC_EXECUTION=0",
    "-Clink-arg=-sALLOW_TABLE_GROWTH=1",
    "-Clink-arg=--js-library=js/embed/soljson_interface.js",
    "-Clink-arg=--pre-js=js/embed/pre.js",
    "-Clink-arg=-sSTACK_SIZE=128kb",
    "-Clink-arg=-sNODEJS_CATCH_EXIT=0"
 ]
@@ -1,7 +0,0 @@
 emsdk
 llvm*/
 target-llvm/
 target/
 node_modules/
 utils/
 build/
@@ -1,127 +0,0 @@
 name: Build revive-wasm
 on:
  push:
    branches: ["main"]
  pull_request:
    branches: ["main"]
  workflow_dispatch:
 env:
  CARGO_TERM_COLOR: always
  REVIVE_WASM_INSTALL_DIR: ${{ github.workspace }}/target/wasm32-unknown-emscripten/release
 jobs:
  build-revive-wasm:
    runs-on: parity-large
    defaults:
      run:
        shell: bash
    steps:
      - uses: actions/checkout@v4
      - name: Cache LLVM build
        id: cache-llvm
        uses: actions/cache@v3
        with:
          path: |
            target-llvm/emscripten/target-final
            target-llvm/gnu/target-final
          # Use a unique key based on LLVM version or configuration files to avoid cache invalidation
          key: llvm-build-${{ runner.os }}-${{ hashFiles('LLVM.lock', 'Cargo.toml', 'Cargo.lock', 'crates/llvm-builder/**', '.github/workflows/build-revive-wasm.yml') }}
      - name: Install system dependencies
        run: |
          sudo apt-get update && sudo apt-get install -y cmake ninja-build curl git libssl-dev pkg-config clang lld
      - name: Install Rust stable toolchain
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
          toolchain: stable
          components: rust-src
          target: wasm32-unknown-emscripten
      - name: Install LLVM build dependencies
        run: |
          make install-llvm-builder
          revive-llvm --target-env emscripten clone
      - name: Setup revive environment variables
        run: |
          echo "LLVM_SYS_181_PREFIX=$(pwd)/target-llvm/gnu/target-final" >> $GITHUB_ENV
          echo "REVIVE_LLVM_TARGET_PREFIX=$(pwd)/target-llvm/emscripten/target-final" >> $GITHUB_ENV
      - name: Build host LLVM
        if: steps.cache-llvm.outputs.cache-hit != 'true'
        run: |
          revive-llvm build --llvm-projects lld --llvm-projects clang
      - name: Build target LLVM
        if: steps.cache-llvm.outputs.cache-hit != 'true'
        run: |
          source emsdk/emsdk_env.sh
          revive-llvm --target-env emscripten build --llvm-projects lld
      - run: |
          rustup show
          cargo --version
          rustup +nightly show
          cargo +nightly --version
          cmake --version
          bash --version
      - name: Use Cached LLVM
        if: steps.cache-llvm.outputs.cache-hit == 'true'
        run: |
          echo "Using cached LLVM"
      - name: Build revive
        run: |
          source emsdk/emsdk_env.sh
          make install-wasm
      - uses: actions/upload-artifact@v4
        with:
          name: revive-wasm
          path: |
            ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.js
            ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc.wasm
            ${{ env.REVIVE_WASM_INSTALL_DIR }}/resolc_web.js
          retention-days: 1
  test-revive-wasm:
    needs: build-revive-wasm
    strategy:
      matrix:
        os: ["ubuntu-24.04", "macos-14", "windows-2022"]
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v4
      - name: Create Target Directory
        run: mkdir -p ${{ env.REVIVE_WASM_INSTALL_DIR }}
      - name: Download Artifact
        uses: actions/download-artifact@v4
        with:
          name: revive-wasm
          path: ${{ env.REVIVE_WASM_INSTALL_DIR }}
      - name: Set Up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "20"
      - name: Install packages
        run: npm install
      - name: Run Playwright tests
        run: |
          cd js
          npx playwright install --with-deps
          npx playwright test
      - name: Test revive
        run: |
          echo "Running tests for ${{ matrix.os }}"
          npm run test:wasm
@@ -1,347 +0,0 @@
 name: Release
 run-name: Release ${{ github.ref_name }}
 on:
  push:
    branches:
      - 'main'
 concurrency:
  group: ${{ github.ref }}-${{ github.workflow }}
  cancel-in-progress: true
 env:
  #rust-musl-cross:x86_64-musl
  RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:68b86bc7cb2867259e6b233415a665ff4469c28b57763e78c3bfea1c68091561
 jobs:
  #
  #
  #
  tag:
    runs-on: ubuntu-24.04
    permissions:
      contents: write
    outputs:
      TAG: ${{ steps.versions.outputs.TAG }}
      PKG_VER: ${{ steps.versions.outputs.PKG_VER }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          fetch-tags: 'true'
          fetch-depth: 0
      - name: Versions
        id: versions
        run: |
          export CURRENT_TAG=$(git describe --tags --abbrev=0 --exclude "llvm-*")
          export PKG_VER=v$(cat Cargo.toml | grep -A 5 package] | grep version | cut -d '=' -f 2 | tr -d '"' | tr -d " ")
          echo "Current tag $CURRENT_TAG"
          echo "Package version $PKG_VER"
          #
          echo "PKG_VER=$PKG_VER" >> $GITHUB_OUTPUT
          if [ $CURRENT_TAG == $PKG_VER  ];
            then
              echo "Tag is up to date. Nothing to do.";
              export TAG=old;
            else
              echo "Tag was updated.";
              export TAG=new;
            fi
          echo "TAG=$TAG" >> $GITHUB_OUTPUT
  #
  #
  #
  build-linux-all:
    if: ${{ needs.tag.outputs.TAG == 'new' }}
    runs-on: parity-large
    needs: [tag]
    steps:
      - uses: actions/checkout@v4
      - name: install linux deps
        run: |
          sudo apt-get update && sudo apt-get install -y cmake ninja-build \
          curl git libssl-dev pkg-config clang lld musl
      - name: Install Rust stable toolchain
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
          toolchain: stable
          components: rust-src
          target: wasm32-unknown-emscripten
      - name: versions
        run: |
          rustup show
          cargo --version
          cmake --version
          echo "bash:" && bash --version
          echo "ninja:" && ninja --version
          echo "clang:" && clang --version
      - name: build revive-llvm
        run: make install-llvm-builder
      # musl LLVM
      - name: llvm-musl-cache restore
        id: llvm-musl-cache
        uses: actions/cache/restore@v4
        with:
          path: target-llvm/musl/target-final
          key: llvm-linux-musl-${{ hashFiles('crates/solidity/**') }}
      - name: Build musl LLVM
        if: steps.llvm-musl-cache.outputs.cache-hit != 'true'
        run: |
          revive-llvm --target-env musl clone
          revive-llvm --target-env musl build --llvm-projects lld --llvm-projects clang
      - name: llvm-musl-cache save
        if: steps.llvm-musl-cache.outputs.cache-hit != 'true'
        uses: actions/cache/save@v4
        with:
          path: target-llvm/musl/target-final
          key: llvm-linux-musl-${{ hashFiles('crates/solidity/**') }}
      # emscripten LLVM
      - name: llvm-emscripten-cache restore
        id: llvm-emscripten-cache
        uses: actions/cache/restore@v4
        with:
          path: |
            target-llvm/emscripten/target-final
            emsdk
          key: llvm-linux-emscripten-${{ hashFiles('crates/solidity/**') }}
      - name: Build emscripten LLVM
        if: steps.llvm-emscripten-cache.outputs.cache-hit != 'true'
        run: |
          revive-llvm --target-env emscripten clone
          source emsdk/emsdk_env.sh
          revive-llvm --target-env emscripten build --llvm-projects lld
      - name: llvm-emscripten-cache save
        if: steps.llvm-emscripten-cache.outputs.cache-hit != 'true'
        uses: actions/cache/save@v4
        with:
          path: |
            target-llvm/emscripten/target-final
            emsdk
          key: llvm-linux-emscripten-${{ hashFiles('crates/solidity/**') }}
      # Build revive
      - name: build musl
        run: |
          mkdir resolc-out
          docker run -v $PWD:/opt/revive $RUST_MUSL_CROSS_IMAGE /bin/bash -c "
           cd /opt/revive
           apt update && apt upgrade -y && apt install -y pkg-config
           export LLVM_SYS_181_PREFIX=/opt/revive/target-llvm/musl/target-final
           make install-bin
           cp /root/.cargo/bin/resolc /opt/revive/resolc-out/resolc
           "
      - name: check musl
        run: |
          mkdir solc
          curl -sSLo solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.28/solc-static-linux
          chmod +x solc/solc
          PATH=$PWD/solc:$PATH
          result=$(./resolc-out/resolc --bin crates/integration/contracts/flipper.sol)
          echo $result
          if [[ $result == *'0x50564d'* ]]; then exit 0; else exit 1; fi
      - name: Set Up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: "20"
      - name: build wasm
        run: |
          export LLVM_SYS_181_PREFIX=$PWD/target-llvm/musl/target-final
          export REVIVE_LLVM_TARGET_PREFIX=$PWD/target-llvm/emscripten/target-final
          source emsdk/emsdk_env.sh
          rustup target add wasm32-unknown-emscripten
          make install-wasm
      - name: check wasm
        run: |
          curl -sSLo solc/soljson.js https://github.com/ethereum/solidity/releases/download/v0.8.28/soljson.js
          node -e "
          const soljson = require('solc/soljson');
          const createRevive = require('./target/wasm32-unknown-emscripten/release/resolc.js');
          const compiler = createRevive();
          compiler.soljson = soljson;
          const standardJsonInput =
          {
            language: 'Solidity',
            sources: {
              'MyContract.sol': {
                content: 'pragma solidity ^0.8.0; contract MyContract { function greet() public pure returns (string memory) { return \'Hello\'; } }',
              },
            },
            settings: { optimizer: { enabled: false } }
          };
          compiler.writeToStdin(JSON.stringify(standardJsonInput));
          compiler.callMain(['--standard-json']);
          // Collect output
          const stdout = compiler.readFromStdout();
          const stderr = compiler.readFromStderr();
          if (stderr) { console.error(stderr); process.exit(1); }
          let out = JSON.parse(stdout);
          let bytecode = out.contracts['MyContract.sol']['MyContract'].evm.bytecode.object
          console.log(bytecode);
          if(!bytecode.startsWith('50564d')) { process.exit(1); }
          "
      - uses: actions/upload-artifact@v4
        with:
          name: revive-wasm
          path: |
            ./target/wasm32-unknown-emscripten/release/resolc.js
            ./target/wasm32-unknown-emscripten/release/resolc.wasm
            ./target/wasm32-unknown-emscripten/release/resolc_web.js
          retention-days: 1
      - uses: actions/upload-artifact@v4
        with:
          name: revive-linux
          path: |
            ./resolc-out/resolc
          retention-days: 1
  #
  #
  #
  create-release:
    needs: [tag, build-linux-all]
    runs-on: ubuntu-24.04
    permissions:
      contents: write
    outputs:
      upload_url: ${{ steps.create_release.outputs.result }}
    steps:
      - uses: actions/checkout@v4
      - name: Create/update tag
        id: tag
        uses: actions/github-script@v7
        with:
          result-encoding: string
          script: |
            await github.rest.git.createRef({
              owner: context.repo.owner,
              repo: context.repo.repo,
              ref: 'refs/tags/${{ needs.tag.outputs.PKG_VER }}',
              sha: context.sha
            })
      - name: get relese notes
        id: get-notes
        run: |
          {
            echo 'releaseNotes<<EOF'
            sed '/^## ${{ needs.tag.outputs.PKG_VER }}/,/^## v/!d' CHANGELOG.md | sed -e '1d' -e '$d'
            echo EOF
          } >> "$GITHUB_OUTPUT"
      - name: Create release
        id: create_release
        env:
         releaseNotes: ${{ steps.get-notes.outputs.releaseNotes }}
         version: ${{ needs.tag.outputs.PKG_VER }}
        uses: actions/github-script@v7
        with:
          result-encoding: string
          script: |
            let response = await github.rest.repos.createRelease({
                owner: context.repo.owner,
                repo: context.repo.repo,
                tag_name: process.env.version,
                name: process.env.version,
                body: process.env.releaseNotes,
                draft: true,
                prerelease: true
            });
            console.log(response);
            return response.data.upload_url;
      - name: Log
        run: |
          echo "tag result:   ${{ needs.tag.outputs.TAG }}"
          echo "pkg version:  ${{ needs.tag.outputs.PKG_VER }}"
  #
  #
  #
  upload-assets:
    runs-on: ubuntu-24.04
    needs: [create-release]
    steps:
      - name: Download Artifact
        uses: actions/download-artifact@v4
        with:
          name: revive-wasm
          path: resolc/
      - name: Download Artifact
        uses: actions/download-artifact@v4
        with:
          name: revive-linux
          path: resolc/
      - name: upload resolc
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.upload_url }}
          asset_path: ./resolc/resolc
          asset_name: resolc-static-linux
          asset_content_type: application/octet-stream
      - name: upload resolc.js
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.upload_url }}
          asset_path: ./resolc/resolc.js
          asset_name: resolc.js
          asset_content_type: application/octet-stream
      - name: upload resolc.wasm
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.upload_url }}
          asset_path: ./resolc/resolc.wasm
          asset_name: resolc.wasm
          asset_content_type: application/octet-stream
      - name: upload resolc_web.js
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ needs.create-release.outputs.upload_url }}
          asset_path: ./resolc/resolc_web.js
          asset_name: resolc_web.js
          asset_content_type: application/octet-stream
@@ -1,58 +0,0 @@
 name: Build
 on:
  push:
    branches: ["main"]
  pull_request:
    branches: ["main"]
 env:
  CARGO_TERM_COLOR: always
 jobs:
  build-ubuntu-x86:
    runs-on: ubuntu-24.04
    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/paritytech/revive/releases/download/v0.1.0-dev.7/clang+llvm-18.1.8-x86_64-linux-gnu-ubuntu-24.04.tar.xz
          mkdir llvm18
          tar Jxf llvm.tar.xz -C llvm18/
          echo "LLVM_SYS_181_PREFIX=$(pwd)/llvm18" >> $GITHUB_ENV
      - name: Install geth
        run: |
          sudo add-apt-repository -y ppa:ethereum/ethereum
          sudo apt update
          sudo apt install -y ethereum
      - name: Machete
        uses: bnjbvr/cargo-machete@main
      - 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
@@ -1,21 +0,0 @@
 /target
 target-llvm
 *.dot
 .vscode/
 .DS_Store
 /*.sol
 /*.yul
 /*.ll
 /*.s
 /llvm*
 node_modules
 artifacts
 tmp
 package-lock.json
 /*.html
 /build
 soljson.js
 test-results
 playwright-report
 .cache
 emsdk
@@ -1,141 +0,0 @@
 # Changelog
 ## Unreleased
 This is a development pre-release.
 Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
 ## v0.1.0-dev.11
 This is a development pre-release.
 Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
 ### Added
 ### Changed 
 ### Fixed
 - A bug causing incorrect loads from the emulated EVM linear memory.
 - A missing integer truncate after switching to 64bit.
 ## v0.1.0-dev.10
 This is a development pre-release.
 Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
 ### Added
 - Support for the `coinbase` opcode.
 - The resolc web JS version.
 ### Changed 
 - Missing the `--overwrite` flag emits an error instead of a warning.
 - The `resolc` executable prints the help by default.
 - Removed support for legacy EVM assembly (EVMLA) translation.
 - integration: identify cached code blobs on source code to fix potential confusions.
 - Setting base, include or allow paths in emscripten is now a hard error.
 - Employ a heuristic to detect `address.transfer` and `address.send` calls.
  If detected, the re-entrant call flag is not set and 0 deposit limit is endowed.
 ### Fixed
 - Solidity: Add the solc `--libraries` files to sources.
 - A data race in tests.
 - Fix `broken pipe` errors.
 - llvm-builder: Allow warnings.
 - solidity: Fix the custom compiler warning messages.
 ## v0.1.0-dev.9
 This is a development pre-release.
 ### Added
 ### Changed 
 - Syscalls with more than 6 arguments now pack them into registers.
 ### Fixed
 - Remove reloading of the resolc.js file (fix issue with relative path in web worker)
 ## v0.1.0-dev.8
 This is a development pre-release.
 ### Added
 - The `revive-llvm-builder` crate with the `revive-llvm` helper utility for streamlined management of the LLVM framework dependency.
 - Initial support for running `resolc` in the browser.
 ### Changed
 - Suported contracts runtime is polkadot-sdk git version `d62a90c8c729acd98c7e9a5cab9803b8b211ffc5`.
 - The minimum supported Rust version is `1.81.0`.
 - Error out early instead of invoking `solc` with invalid base or include path flags.
 ### Fixed
 - Decouple the LLVM target dependency from the LLVM host dependency.
 - Do not error out if no files and no errors were produced. This aligns resolc closer to solc.
 - Fixes input normalization in the Wasm version.
 ## v0.1.0-dev.7
 This is a development pre-release.
 ### Added
 - Implement the `GASPRICE` opcode.
 - Implement the `BASEFEE` opcode.
 - Implement the `GASLIMIT` opcode.
 ### Changed
 - The `GAS` opcode now returns the remaining `ref_time`.
 - Contracts can now be supplied call data input of arbitrary size.
 - Some syscalls now return the value in a register, slightly improving  emitted contract code.
 - Calls forward maximum weight limits instead of 0, anticipating a change in polkadot-sdk where weight limits of 0 no longer interprets as uncapped limit.
 ### Fixed
 - A linker bug which was preventing certain contracts from linking with the PVM linker. 
 - JS: Fix encoding conversion from JS string (UTF-16) to UTF-8.
 - The git commit hash slug is always displayed in the version string. 
 ## v0.1.0-dev.6
 This is a development pre-release.
 # Added
 - Implement the `BLOCKHASH` opcode.
 - Implement delegate calls.
 - Implement the `GASPRICE` opcode. Currently hard-coded to return `1`.
 - The ELF shared object contract artifact is dumped into the debug output directory.
 - Initial support for emitting debug info (opt in via the `-g` flag)
 # Changed
 - resolc now emits 64bit PolkaVM blobs, reducing contract code size and execution time.
 - The RISC-V bit-manipulation target feature (`zbb`) is enabled.
 # Fixed
 - Compilation to Wasm (for usage in node and web browsers)
 ## v0.1.0-dev.5
 This is development pre-release.
 # Added
 - Implement the `CODESIZE` and `EXTCODESIZE` opcodes.
 # Changed
 - Include the full revive version in the contract metadata.
 # Fixed
 ## v0.1.0-dev-4
 This is development pre-release.
 # Added
 - Support the `ORIGIN` opcode.
 # Changed
 - Update polkavm to `v0.14.0`.
 - Enable the `a`, `fast-unaligned-access` and `xtheadcondmov` LLVM target features, decreasing the code size for some contracts.
 # Fixed
@@ -1,87 +0,0 @@
 [workspace]
 resolver = "2"
 members = ["crates/*"]
 [workspace.package]
 version = "0.1.0-dev.11"
 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.81.0"
 [workspace.dependencies]
 revive-benchmarks = { version = "0.1.0-dev.11", path = "crates/benchmarks" }
 revive-builtins = { version = "0.1.0-dev.11", path = "crates/builtins" }
 revive-common = { version = "0.1.0-dev.11", path = "crates/common" }
 revive-differential = { version = "0.1.0-dev.11", path = "crates/differential" }
 revive-integration = { version = "0.1.0-dev.11", path = "crates/integration" }
 revive-linker = { version = "0.1.0-dev.11", path = "crates/linker" }
 lld-sys = { version = "0.1.0-dev.11", path = "crates/lld-sys" }
 revive-llvm-context = { version = "0.1.0-dev.11", path = "crates/llvm-context" }
 revive-runtime-api = { version = "0.1.0-dev.11", path = "crates/runtime-api" }
 revive-runner = { version = "0.1.0-dev.11", path = "crates/runner" }
 revive-solidity = { version = "0.1.0-dev.11", path = "crates/solidity" }
 revive-stdlib = { version = "0.1.0-dev.11", path = "crates/stdlib" }
 revive-build-utils = { version = "0.1.0-dev.11", path = "crates/build-utils" }
 hex = "0.4.3"
 cc = "1.2"
 libc = "0.2.169"
 tempfile = "3.17"
 anyhow = "1.0"
 semver = { version = "1.0", features = ["serde"] }
 itertools = "0.14"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["arbitrary_precision"] }
 regex = "1.10"
 once_cell = "1.20"
 num = "0.4.3"
 sha1 = "0.10"
 sha3 = "0.10"
 thiserror = "2.0"
 which = "7.0"
 path-slash = "0.2"
 rayon = "1.8"
 clap = { version = "4", default-features = false, features = ["derive"] }
 polkavm-common = "0.21.0"
 polkavm-linker = "0.21.0"
 polkavm-disassembler = "0.21.0"
 polkavm = "0.21.0"
 alloy-primitives = { version = "0.8.21", features = ["serde"] }
 alloy-sol-types = "0.8.21"
 alloy-genesis = "0.11.1"
 alloy-serde = "0.11.1"
 env_logger = { version = "0.11.6", default-features = false }
 serde_stacker = "0.1.11"
 criterion = { version = "0.5.1", features = ["html_reports"] }
 log = { version = "0.4.25" }
 git2 = { version = "0.20.0", default-features = false }
 downloader = "0.2.8"
 flate2 = "1.0.35"
 fs_extra = "1.3.0"
 num_cpus = "1"
 tar = "0.4"
 toml = "0.8"
 assert_cmd = "2.0"
 assert_fs = "1.1"
 # polkadot-sdk and friends
 codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
 scale-info = { version = "2.11.6", default-features = false }
 polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "274a781e8ca1a9432c7ec87593bd93214abbff50" }
 # llvm
 [workspace.dependencies.inkwell]
 git = "https://github.com/TheDan64/inkwell.git"
 rev = "7b410298b6a93450adaa90b1841d5805a3038f12"
 default-features = false
 features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
 [profile.bench]
 inherits = "release"
 lto = true
 codegen-units = 1
@@ -1,32 +0,0 @@
 FROM rust:1.84.0 AS llvm-builder
 WORKDIR /opt/revive
 RUN apt update && \ 
    apt upgrade -y && \
    apt install -y cmake ninja-build curl git libssl-dev pkg-config clang lld musl
 COPY . .
 RUN make install-llvm-builder
 RUN revive-llvm --target-env musl clone
 RUN revive-llvm --target-env musl build  --llvm-projects lld --llvm-projects clang
 FROM messense/rust-musl-cross:x86_64-musl AS resolc-builder
 WORKDIR /opt/revive
 RUN apt update && \ 
    apt upgrade -y && \
    apt install -y pkg-config
 COPY . .
 COPY --from=llvm-builder /opt/revive/target-llvm /opt/revive/target-llvm
 ENV LLVM_SYS_181_PREFIX=/opt/revive/target-llvm/musl/target-final
 RUN make install-bin
 FROM alpine:latest
 ADD https://github.com/ethereum/solidity/releases/download/v0.8.28/solc-static-linux /usr/bin/solc
 COPY --from=resolc-builder /root/.cargo/bin/resolc /usr/bin/resolc
 RUN apk add --no-cache libc6-compat
 RUN chmod +x /usr/bin/solc 
@@ -1,191 +0,0 @@
                                 Apache License
                           Version 2.0, January 2004
                        https://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   Copyright (c) 2019 Matter Labs
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       https://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
@@ -1,21 +0,0 @@
 MIT License
 Copyright (c) 2019 Matter Labs
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
@@ -1,3 +0,0 @@
 url = "https://github.com/llvm/llvm-project.git"
 branch = "release/18.x"
 ref = "3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff"
@@ -1,94 +0,0 @@
 .PHONY: \
 	install \
 	install-bin \
 	install-npm \
 	install-wasm \
 	install-llvm-builder \
 	install-llvm \
 	format \
 	clippy \
 	machete \
 	test \
 	test-integration \
 	test-solidity \
 	test-workspace \
 	test-cli \
 	test-wasm \
 	test-llvm-builder
 	bench \
 	bench-pvm \
 	bench-evm \
 	clean
 install: install-bin install-npm
 install-bin:
 	cargo install --path crates/solidity
 install-npm:
 	npm install && npm fund
 install-wasm: install-npm
 	cargo build --target wasm32-unknown-emscripten -p revive-solidity --release --no-default-features
 	npm run build:package
 install-llvm-builder:
 	cargo install --path crates/llvm-builder
 install-llvm: install-llvm-builder
 	revive-llvm clone
 	revive-llvm build --llvm-projects lld --llvm-projects clang
 format:
 	cargo fmt --all --check
 clippy:
 	cargo clippy --all-features --workspace --tests --benches -- --deny warnings
 machete:
 	cargo install cargo-machete
 	cargo machete
 test: format clippy machete test-cli test-workspace
 test-integration: install-bin
 	cargo test --package revive-integration
 test-solidity: install
 	cargo test --package revive-solidity
 test-workspace: install
 	cargo test --workspace --exclude revive-llvm-builder
 test-cli: install
 	npm run test:cli
 test-wasm: install-wasm
 	npm run test:wasm
 test-llvm-builder:
 	@echo "warning: the llvm-builder tests will take many hours"
 	cargo test --package revive-llvm-builder -- --test-threads=1
 bench: install-bin
 	cargo criterion --all --all-features --message-format=json \
 	| criterion-table > crates/benchmarks/BENCHMARKS.md
 bench-pvm: install-bin
 	cargo criterion --bench execute --features bench-pvm-interpreter --message-format=json \
 	| criterion-table > crates/benchmarks/PVM.md
 bench-evm: install-bin
 	cargo criterion --bench execute --features bench-evm --message-format=json \
 	| criterion-table > crates/benchmarks/EVM.md
 clean:
 	cargo clean ; \
 	revive-llvm clean ; \
 	rm -rf node_modules ; \
 	rm -rf crates/solidity/src/tests/cli-tests/artifacts ; \
 	cargo uninstall revive-solidity ; \
 	cargo uninstall revive-llvm-builder ; \
 	rm -f package-lock.json ; \
 	rm -rf js/dist ; \
 	rm -f js/src/resolc.{wasm,js}
@@ -1,85 +0,0 @@
 ![CI](https://github.com/paritytech/revive/actions/workflows/rust.yml/badge.svg)
 [![Docs](https://img.shields.io/badge/Docs-contracts.polkadot.io-brightgreen.svg)](https://contracts.polkadot.io)
 # revive
 YUL recompiler to LLVM, targetting RISC-V on [PolkaVM](https://github.com/koute/polkavm).
 Visit [contracts.polkadot.io](https://contracts.polkadot.io) to learn more about contracts on Polkadot!
 ## Status
 This is experimental software in active development and not ready just yet for production usage. Please do report any compiler related issues or missing features that are [not yet known to us](https://contracts.polkadot.io/known_issues/) here.
 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).
 ## Installation
 `resolc` depends on the [solc](https://github.com/ethereum/solidity) binary installed on your system.
 Download and install the `resolc` frontend executable for your platform from our [releases](https://github.com/paritytech/revive/releases).
 ## Building from source
 Building revive requires a [stable Rust installation](https://rustup.rs/) and a C++ toolchain for building [LLVM](https://github.com/llvm/llvm-project) on your system.
 ### LLVM
 `revive` depends on a custom build of LLVM `v18.1.8` with the RISC-V _embedded_ target, including the `compiler-rt` builtins. Use the provided [revive-llvm](crates/llvm-builder/README.md) utility to compile a compatible LLVM build locally and point `$LLVM_SYS_181_PREFIX` to the installation afterwards.
 The `Makefile` provides a shortcut target to obtain a compatible LLVM build:
 ```bash
 make install-llvm
 export LLVM_SYS_181_PREFIX=${PWD}/target-llvm/gnu/target-final
 ```
 ### The `resolc` Solidity frontend
 To build the `resolc` Solidity frontend executable, make sure you have obtained a compatible LLVM build using [revive-llvm](crates/llvm-builder/README.md) and did export the `LLVM_SYS_181_PREFIX` environment variable pointing to it (see [above](#LLVM)).
 To install the `resolc` Solidity frontend executable:
 ```bash
 make install-bin
 resolc --version
 ```
 ### Cross-compilation to Wasm
 Cross-compile the `resolc.js` frontend executable to Wasm for running it in a Node.js or browser environment. The `REVIVE_LLVM_TARGET_PREFIX` environment variable is used to control the target environment LLVM dependency.
 ```bash
 # Build the host LLVM dependency with PolkaVM target support
 make install-llvm
 export LLVM_SYS_181_PREFIX=${PWD}/target-llvm/gnu/target-final
 # Build the target LLVM dependency with PolkaVM target support
 revive-llvm --target-env emscripten clone
 source emsdk/emsdk_env.sh
 revive-llvm --target-env emscripten build --llvm-projects lld
 export REVIVE_LLVM_TARGET_PREFIX=${PWD}/target-llvm/emscripten/target-final
 # Build the resolc frontend executable
 make install-wasm
 make test-wasm
 ```
 ### Development
 Please consult the [Makefile](Makefile) targets to learn how to run tests and benchmarks. 
 Ensure that your branch passes `make test` locally when submitting a pull request.
 ## Design overview
 `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).
 [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`.
 ## Tests
 Before running the tests, ensure that Geth (Go Ethereum) is installed on your system. Follow the installation guide here: [Installing Geth](https://geth.ethereum.org/docs/getting-started/installing-geth).
 Once Geth is installed, you can run the tests using the following command:
 ```bash
 make test
 ```
@@ -1,10 +0,0 @@
 # Release checklist
 Prior to the first stable release we neither have formal release processes nor do we follow a fixed release schedule.
 To create a new pre-release:
 1. Merge a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly. The release workflow will attempt to build and publish a new release whenever the latest git tag does not match the cargo package version.
 2. Wait for the `Release` workflow to finish. If the workflow fails after the `build-linux-all` step, check if a tag has been created and delete it before restarting or pushing updates. Note: It's more convenient to debug the release workflow in a fork (the fork has to be under the `paritytech` org to access `parity-large` runners).
 3. Check draft release on [Releases page](https://github.com/paritytech/revive/releases) and publish (should contain `resolc.js`, `resolc.wasm`, `resolc-web.js`, and `resolc-static-linux` release assets)
 4. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly
@@ -1 +0,0 @@
 https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/SECURITY.md
@@ -1,30 +0,0 @@
 # Known issues
 The following is known and we are either working on it or it is a hard limitation. Please do not open a new issue.
 ## Release
 `0.1.0-dev-2`
 ## Missing features
 - [Libraries with public functions are not supported](https://github.com/paritytech/revive/issues/91)
 - [Automatic import resolution is not supported](https://github.com/paritytech/revive/issues/98)
 - The emulated EVM linear contract memory is limited to 64kb in size. Will be fixed with support for metered dynamic memory.
 - [The contract calldata is currently limited to 1kb in size](https://github.com/paritytech/revive/issues/57)
 - [EIP-4844 opcodes are not supported](https://github.com/paritytech/revive/issues/64)
 - [Delegate calls are not supported](https://github.com/paritytech/revive/issues/67)
 - [The `blockhash` opcode is not supported](https://github.com/paritytech/revive/issues/61)
 - [The `extcodesize` opcode is not supported](https://github.com/paritytech/revive/issues/58)
 - [The `origin` opcode is not supported](https://github.com/paritytech/revive/issues/59)
 - [Gas limits for contract calls are ignored](https://github.com/paritytech/revive/issues/60)
 - [Gas related opcodes are not supported](https://github.com/paritytech/revive/issues/60)
 - IPFS metadata hashes are not supported
 - [Compiled contract artifacts can exceed the pallet static memory limit and fail to deploy](https://github.com/paritytech/revive/issues/96).
 - [Transfers to inexistant accounts will fail if the transferred value lies below the ED.](https://github.com/paritytech/revive/issues/83) Will be fixed in the pallet to make the ED completely transparent for contracts.
 ## Wontfix
 Please consult our documentation to learn more about Solidity and EVM features likely to remain unsupported (and why they will not be supported).
 TODO: Insert link to the relevant documentation section.
@@ -1,73 +0,0 @@
 # Benchmarks
 ## Table of Contents
 - [Benchmark Results](#benchmark-results)
    - [Baseline](#baseline)
    - [OddPorduct](#oddporduct)
    - [TriangleNumber](#trianglenumber)
    - [FibonacciRecursive](#fibonaccirecursive)
    - [FibonacciIterative](#fibonacciiterative)
    - [FibonacciBinet](#fibonaccibinet)
    - [SHA1](#sha1)
 ## Benchmark Results
 ### Baseline
 |         | `EVM`                   | `PVMInterpreter`                 |
 |:--------|:------------------------|:-------------------------------- |
 | **`0`** | `3.36 us` (✅ **1.00x**) | `11.84 us` (❌ *3.52x slower*)    |
 ### OddPorduct
 |              | `EVM`                    | `PVMInterpreter`                 |
 |:-------------|:-------------------------|:-------------------------------- |
 | **`10000`**  | `3.11 ms` (✅ **1.00x**)  | `1.53 ms` (🚀 **2.03x faster**)   |
 | **`100000`** | `30.70 ms` (✅ **1.00x**) | `15.54 ms` (🚀 **1.98x faster**)  |
 | **`300000`** | `92.68 ms` (✅ **1.00x**) | `45.47 ms` (🚀 **2.04x faster**)  |
 ### TriangleNumber
 |              | `EVM`                    | `PVMInterpreter`                 |
 |:-------------|:-------------------------|:-------------------------------- |
 | **`10000`**  | `2.29 ms` (✅ **1.00x**)  | `1.09 ms` (🚀 **2.11x faster**)   |
 | **`100000`** | `22.84 ms` (✅ **1.00x**) | `10.66 ms` (🚀 **2.14x faster**)  |
 | **`360000`** | `82.29 ms` (✅ **1.00x**) | `37.01 ms` (🚀 **2.22x faster**)  |
 ### FibonacciRecursive
 |          | `EVM`                     | `PVMInterpreter`                  |
 |:---------|:--------------------------|:--------------------------------- |
 | **`12`** | `135.67 us` (✅ **1.00x**) | `125.02 us` (✅ **1.09x faster**)  |
 | **`16`** | `903.75 us` (✅ **1.00x**) | `762.79 us` (✅ **1.18x faster**)  |
 | **`20`** | `6.12 ms` (✅ **1.00x**)   | `4.96 ms` (✅ **1.23x faster**)    |
 | **`24`** | `42.05 ms` (✅ **1.00x**)  | `33.86 ms` (✅ **1.24x faster**)   |
 ### FibonacciIterative
 |           | `EVM`                    | `PVMInterpreter`                 |
 |:----------|:-------------------------|:-------------------------------- |
 | **`64`**  | `15.04 us` (✅ **1.00x**) | `29.45 us` (❌ *1.96x slower*)    |
 | **`128`** | `26.36 us` (✅ **1.00x**) | `42.19 us` (❌ *1.60x slower*)    |
 | **`256`** | `48.61 us` (✅ **1.00x**) | `65.71 us` (❌ *1.35x slower*)    |
 ### FibonacciBinet
 |           | `EVM`                    | `PVMInterpreter`                 |
 |:----------|:-------------------------|:-------------------------------- |
 | **`64`**  | `15.22 us` (✅ **1.00x**) | `41.46 us` (❌ *2.72x slower*)    |
 | **`128`** | `17.05 us` (✅ **1.00x**) | `42.84 us` (❌ *2.51x slower*)    |
 | **`256`** | `19.00 us` (✅ **1.00x**) | `44.36 us` (❌ *2.34x slower*)    |
 ### SHA1
 |           | `EVM`                     | `PVMInterpreter`                  |
 |:----------|:--------------------------|:--------------------------------- |
 | **`1`**   | `110.04 us` (✅ **1.00x**) | `216.11 us` (❌ *1.96x slower*)    |
 | **`64`**  | `209.04 us` (✅ **1.00x**) | `309.48 us` (❌ *1.48x slower*)    |
 | **`512`** | `903.65 us` (✅ **1.00x**) | `980.49 us` (✅ **1.09x slower**)  |
 ---
 Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
@@ -1,28 +0,0 @@
 [package]
 name = "revive-benchmarks"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors.workspace = true
 description = "revive compiler benchmarks"
 [features]
 default = ["bench-pvm-interpreter"]
 bench-pvm-interpreter = ["revive-runner"]
 bench-evm = ["revive-differential"]
 [dependencies]
 hex = { workspace = 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
@@ -1,124 +0,0 @@
 #![cfg(any(feature = "bench-pvm-interpreter", feature = "bench-evm"))]
 use alloy_primitives::U256;
 use criterion::{
    criterion_group, criterion_main,
    measurement::{Measurement, WallTime},
    BenchmarkGroup, BenchmarkId, Criterion,
 };
 use revive_integration::cases::Contract;
 fn bench<P, L, I>(
    mut group: BenchmarkGroup<'_, WallTime>,
    parameters: &[P],
    labels: &[L],
    contract: I,
 ) where
    P: Clone,
    L: std::fmt::Display,
    I: Fn(P) -> Contract,
 {
    assert_eq!(parameters.len(), labels.len());
    group.sample_size(10);
    for (p, l) in parameters.iter().zip(labels.iter()) {
        let contract = contract(p.clone());
        #[cfg(feature = "bench-evm")]
        group.bench_with_input(BenchmarkId::new("EVM", l), p, |b, _| {
            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")]
        group.bench_with_input(BenchmarkId::new("PVMInterpreter", l), p, |b, _| {
            let specs = revive_benchmarks::create_specs(&contract);
            b.iter_custom(|iters| revive_benchmarks::measure_pvm(&specs, iters));
        });
    }
    group.finish();
 }
 fn group<'error, M>(c: &'error mut Criterion<M>, group_name: &str) -> BenchmarkGroup<'error, M>
 where
    M: Measurement,
 {
    c.benchmark_group(group_name)
 }
 fn bench_baseline(c: &mut Criterion) {
    let group = group(c, "Baseline");
    let parameters = &[0u8];
    bench(group, parameters, parameters, |_| Contract::baseline());
 }
 fn bench_odd_product(c: &mut Criterion) {
    let group = group(c, "OddPorduct");
    let parameters = &[10_000, 100_000, 300000];
    bench(group, parameters, parameters, Contract::odd_product);
 }
 fn bench_triangle_number(c: &mut Criterion) {
    let group = group(c, "TriangleNumber");
    let parameters = &[10_000, 100_000, 360000];
    bench(group, parameters, parameters, Contract::triangle_number);
 }
 fn bench_fibonacci_recurisve(c: &mut Criterion) {
    let group = group(c, "FibonacciRecursive");
    let parameters = [12, 16, 20, 24]
        .iter()
        .map(|p| U256::from(*p))
        .collect::<Vec<_>>();
    bench(group, &parameters, &parameters, Contract::fib_recursive);
 }
 fn bench_fibonacci_iterative(c: &mut Criterion) {
    let group = group(c, "FibonacciIterative");
    let parameters = [64, 128, 256]
        .iter()
        .map(|p| U256::from(*p))
        .collect::<Vec<_>>();
    bench(group, &parameters, &parameters, Contract::fib_iterative);
 }
 fn bench_fibonacci_binet(c: &mut Criterion) {
    let group = group(c, "FibonacciBinet");
    let parameters = [64, 128, 256]
        .iter()
        .map(|p| U256::from(*p))
        .collect::<Vec<_>>();
    bench(group, &parameters, &parameters, Contract::fib_binet);
 }
 fn bench_sha1(c: &mut Criterion) {
    let group = group(c, "SHA1");
    let parameters = &[vec![0xff], vec![0xff; 64], vec![0xff; 512]];
    let labels = parameters.iter().map(|p| p.len()).collect::<Vec<_>>();
    bench(group, parameters, &labels, |input| {
        Contract::sha1(input.into())
    });
 }
 criterion_group!(
    name = execute;
    config = Criterion::default();
    targets = bench_baseline,
    bench_odd_product,
    bench_triangle_number,
    bench_fibonacci_recurisve,
    bench_fibonacci_iterative,
    bench_fibonacci_binet,
    bench_sha1
 );
 criterion_main!(execute);
@@ -1,70 +0,0 @@
 #[cfg(feature = "bench-pvm-interpreter")]
 pub fn create_specs(contract: &revive_integration::cases::Contract) -> revive_runner::Specs {
    use revive_runner::*;
    use SpecsAction::*;
    Specs {
        differential: false,
        actions: vec![
            Instantiate {
                code: Code::Bytes(contract.pvm_runtime.to_vec()),
                origin: TestAddress::Alice,
                data: Default::default(),
                value: Default::default(),
                gas_limit: Default::default(),
                storage_deposit_limit: Default::default(),
                salt: Default::default(),
            },
            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()
    }
 }
 #[cfg(feature = "bench-pvm-interpreter")]
 pub fn measure_pvm(specs: &revive_runner::Specs, iters: u64) -> std::time::Duration {
    use revive_runner::*;
    let mut total_time = std::time::Duration::default();
    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
 }
@@ -1,14 +0,0 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 Cargo.lock
 # These are backup files generated by rustfmt
 **/*.rs.bk
 # IDE
 /.idea/
 /.vscode/
@@ -1,15 +0,0 @@
 [package]
 name = "revive-build-utils"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors = [
    "Cyrill Leutwiler <cyrill@parity.io>",
 ]
 description = "Shared build utilities of the revive compiler"
 [lib]
 doctest = false
 [dependencies]
@@ -1,10 +0,0 @@
 # revive: Compiler Common
 ## License
 This library is distributed under the terms of either
 - Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
 - MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
 at your option.
@@ -1,48 +0,0 @@
 //! The compiler build utilities library.
 /// The revive LLVM host dependency directory prefix environment variable.
 pub const REVIVE_LLVM_HOST_PREFIX: &str = "LLVM_SYS_181_PREFIX";
 /// The revive LLVM target dependency directory prefix environment variable.
 pub const REVIVE_LLVM_TARGET_PREFIX: &str = "REVIVE_LLVM_TARGET_PREFIX";
 /// Constructs a path to the LLVM tool `name`.
 ///
 /// Respects the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
 pub fn llvm_host_tool(name: &str) -> std::path::PathBuf {
    std::env::var_os(REVIVE_LLVM_HOST_PREFIX)
        .map(Into::<std::path::PathBuf>::into)
        .unwrap_or_else(|| {
            panic!(
                "install LLVM using the revive-llvm builder and export {REVIVE_LLVM_HOST_PREFIX}",
            )
        })
        .join("bin")
        .join(name)
 }
 /// Returns the LLVM lib dir.
 ///
 /// Respects the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
 pub fn llvm_lib_dir() -> std::path::PathBuf {
    std::path::PathBuf::from(llvm_config("--libdir").trim())
 }
 /// Returns the LLVM CXX compiler flags.
 ///
 /// Respects the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
 pub fn llvm_cxx_flags() -> String {
    llvm_config("--cxxflags")
 }
 /// Execute the `llvm-config` utility respecting the [`REVIVE_LLVM_HOST_PREFIX`] environment variable.
 fn llvm_config(arg: &str) -> String {
    let llvm_config = llvm_host_tool("llvm-config");
    let output = std::process::Command::new(&llvm_config)
        .arg(arg)
        .output()
        .unwrap_or_else(|error| panic!("`{} {arg}` failed: {error}", llvm_config.display()));
    String::from_utf8(output.stdout)
        .unwrap_or_else(|_| panic!("output of `{} {arg}` should be utf8", llvm_config.display()))
 }
@@ -1,12 +0,0 @@
 [package]
 name = "revive-builtins"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors.workspace = true
 build = "build.rs"
 description = "compiler builtins for the revive compiler"
 [build-dependencies]
 revive-build-utils = { workspace = true }
@@ -1,45 +0,0 @@
 use std::{env, fs, io::Read, path::Path, process::Command};
 pub const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
 fn main() {
    println!(
        "cargo:rerun-if-env-changed={}",
        revive_build_utils::REVIVE_LLVM_HOST_PREFIX
    );
    let llvm_config = revive_build_utils::llvm_host_tool("llvm-config");
    let mut llvm_lib_dir = String::new();
    Command::new(&llvm_config)
        .arg("--libdir")
        .output()
        .unwrap_or_else(|_| {
            panic!(
                "{} should be able to provide LD path",
                llvm_config.display()
            )
        })
        .stdout
        .as_slice()
        .read_to_string(&mut llvm_lib_dir)
        .expect("llvm-config output should be utf8");
    let lib_path = revive_build_utils::llvm_lib_dir()
        .join("unknown")
        .join(BUILTINS_ARCHIVE_FILE);
    let archive = fs::read(&lib_path).expect("clang builtins not found");
    println!("cargo:rerun-if-env-changed={}", lib_path.display());
    let out_dir = env::var_os("OUT_DIR").expect("has OUT_DIR");
    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!(\"{BUILTINS_ARCHIVE_FILE}\");"
    );
    fs::write(src_path, src).expect("can write to OUT_DIR");
    println!("cargo:rerun-if-changed=build.rs");
 }
@@ -1 +0,0 @@
 include!(concat!(env!("OUT_DIR"), "/compiler_rt.rs"));
@@ -1,14 +0,0 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
 Cargo.lock
 # These are backup files generated by rustfmt
 **/*.rs.bk
 # IDE
 /.idea/
 /.vscode/
@@ -1,20 +0,0 @@
 [package]
 name = "revive-common"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors = [
    "Cyrill Leutwiler <cyrill@parity.io>",
    "Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
 ]
 description = "Shared constants of the revive compiler"
 [lib]
 doctest = false
 [dependencies]
 anyhow = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = [ "arbitrary_precision", "unbounded_depth" ] }
 serde_stacker = { workspace = true }
@@ -1,10 +0,0 @@
 # revive: Compiler Common
 ## License
 This library is distributed under the terms of either
 - Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
 - MIT license ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)
 at your option.
@@ -1,13 +0,0 @@
 //! The number base constants.
 /// The binary number base.
 pub const BASE_BINARY: u32 = 2;
 /// The octal number base.
 pub const BASE_OCTAL: u32 = 8;
 /// The decimal number base.
 pub const BASE_DECIMAL: u32 = 10;
 /// The hexadecimal number base.
 pub const BASE_HEXADECIMAL: u32 = 16;
@@ -1,31 +0,0 @@
 //! The common sizes in bits.
 /// The `bool` type bit-length.
 pub const BIT_LENGTH_BOOLEAN: usize = 1;
 /// The `u8` type or byte bit-length.
 pub const BIT_LENGTH_BYTE: usize = 8;
 /// The x86 word type (usually `u32`) bit-length.
 pub const BIT_LENGTH_X32: usize = crate::byte_length::BYTE_LENGTH_X32 * BIT_LENGTH_BYTE;
 /// The x86_64 word type (usually `u64`) bit-length.
 pub const BIT_LENGTH_X64: usize = crate::byte_length::BYTE_LENGTH_X64 * BIT_LENGTH_BYTE;
 /// The ETH address (usually `u160`) bit-length.
 pub const BIT_LENGTH_ETH_ADDRESS: usize =
    crate::byte_length::BYTE_LENGTH_ETH_ADDRESS * BIT_LENGTH_BYTE;
 /// The VM word (usually `u256` or `i256`) bit-length.
 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 = BIT_LENGTH_WORD;
 /// Bit length of thre runimte block number type.
 pub const BIT_LENGTH_BLOCK_NUMBER: usize =
    crate::byte_length::BYTE_LENGTH_BLOCK_NUMBER * BIT_LENGTH_BYTE;
 /// Bit length of thre runimte block timestamp type.
 pub const BIT_LENGTH_BLOCK_TIMESTAMP: usize =
    crate::byte_length::BYTE_LENGTH_BLOCK_TIMESTAMP * BIT_LENGTH_BYTE;
@@ -1,28 +0,0 @@
 //! The common sizes in bytes.
 /// The byte-length.
 pub const BYTE_LENGTH_BYTE: usize = 1;
 /// The x86 word byte-length.
 pub const BYTE_LENGTH_X32: 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;
 /// The word byte-length.
 pub const BYTE_LENGTH_WORD: usize = 32;
 /// Byte length of the runtime value type.
 pub const BYTE_LENGTH_VALUE: usize = 32;
 /// Byte length of the runtime block number type.
 pub const BYTE_LENGTH_BLOCK_NUMBER: usize = 4;
 /// Byte length of the runtime block timestamp type.
 pub const BYTE_LENGTH_BLOCK_TIMESTAMP: usize = 4;
@@ -1,87 +0,0 @@
 //! The EVM version.
 use serde::Deserialize;
 use serde::Serialize;
 /// The EVM version.
 #[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[serde(rename_all = "camelCase")]
 pub enum EVMVersion {
    /// The corresponding EVM version.
    #[serde(rename = "homestead")]
    Homestead,
    /// The corresponding EVM version.
    #[serde(rename = "tangerineWhistle")]
    TangerineWhistle,
    /// The corresponding EVM version.
    #[serde(rename = "spuriousDragon")]
    SpuriousDragon,
    /// The corresponding EVM version.
    #[serde(rename = "byzantium")]
    Byzantium,
    /// The corresponding EVM version.
    #[serde(rename = "constantinople")]
    Constantinople,
    /// The corresponding EVM version.
    #[serde(rename = "petersburg")]
    Petersburg,
    /// The corresponding EVM version.
    #[serde(rename = "istanbul")]
    Istanbul,
    /// The corresponding EVM version.
    #[serde(rename = "berlin")]
    Berlin,
    /// The corresponding EVM version.
    #[serde(rename = "london")]
    London,
    /// The corresponding EVM version.
    #[serde(rename = "paris")]
    Paris,
    /// The corresponding EVM version.
    #[serde(rename = "shanghai")]
    Shanghai,
    /// The corresponding EVM version.
    #[serde(rename = "cancun")]
    Cancun,
 }
 impl TryFrom<&str> for EVMVersion {
    type Error = anyhow::Error;
    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Ok(match value {
            "homestead" => Self::Homestead,
            "tangerineWhistle" => Self::TangerineWhistle,
            "spuriousDragon" => Self::SpuriousDragon,
            "byzantium" => Self::Byzantium,
            "constantinople" => Self::Constantinople,
            "petersburg" => Self::Petersburg,
            "istanbul" => Self::Istanbul,
            "berlin" => Self::Berlin,
            "london" => Self::London,
            "paris" => Self::Paris,
            "shanghai" => Self::Shanghai,
            "cancun" => Self::Cancun,
            _ => anyhow::bail!("Invalid EVM version: {}", value),
        })
    }
 }
 impl std::fmt::Display for EVMVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Homestead => write!(f, "homestead"),
            Self::TangerineWhistle => write!(f, "tangerineWhistle"),
            Self::SpuriousDragon => write!(f, "spuriousDragon"),
            Self::Byzantium => write!(f, "byzantium"),
            Self::Constantinople => write!(f, "constantinople"),
            Self::Petersburg => write!(f, "petersburg"),
            Self::Istanbul => write!(f, "istanbul"),
            Self::Berlin => write!(f, "berlin"),
            Self::London => write!(f, "london"),
            Self::Paris => write!(f, "paris"),
            Self::Shanghai => write!(f, "shanghai"),
            Self::Cancun => write!(f, "cancun"),
        }
    }
 }
@@ -1,7 +0,0 @@
 //! The revive exit code constants.
 /// The common application success exit code.
 pub const EXIT_CODE_SUCCESS: i32 = 0;
 /// The common application failure exit code.
 pub const EXIT_CODE_FAILURE: i32 = 1;
@@ -1,40 +0,0 @@
 //! The file extensions.
 /// The manifest file extension.
 pub static EXTENSION_MANIFEST: &str = "toml";
 /// The JSON data file extension.
 pub static EXTENSION_JSON: &str = "json";
 /// The ABI file extension.
 pub static EXTENSION_ABI: &str = "abi";
 /// The Yul IR file extension.
 pub static EXTENSION_YUL: &str = "yul";
 /// The EVM file extension.
 pub static EXTENSION_EVM: &str = "evm";
 /// The EVM bytecode file extension.
 pub static EXTENSION_EVM_BINARY: &str = "bin";
 /// The Solidity file extension.
 pub static EXTENSION_SOLIDITY: &str = "sol";
 /// The LLL IR file extension.
 pub static EXTENSION_LLL: &str = "lll";
 /// The LLVM source code file extension.
 pub static EXTENSION_LLVM_SOURCE: &str = "ll";
 /// The LLVM bitcode file extension.
 pub static EXTENSION_LLVM_BINARY: &str = "bc";
 /// The PolkaVM assembly file extension.
 pub static EXTENSION_POLKAVM_ASSEMBLY: &str = "pvmasm";
 /// The PolkaVM bytecode file extension.
 pub static EXTENSION_POLKAVM_BINARY: &str = "pvm";
 /// The ELF shared object file extension.
 pub static EXTENSION_SHARED_OBJECT: &str = "so";
@@ -1,17 +0,0 @@
 //! The compiler common library.
 pub(crate) mod base;
 pub(crate) mod bit_length;
 pub(crate) mod byte_length;
 pub(crate) mod evm_version;
 pub(crate) mod exit_code;
 pub(crate) mod extension;
 pub(crate) mod utils;
 pub use self::base::*;
 pub use self::bit_length::*;
 pub use self::byte_length::*;
 pub use self::evm_version::EVMVersion;
 pub use self::exit_code::*;
 pub use self::extension::*;
 pub use self::utils::*;
@@ -1,27 +0,0 @@
 //! The compiler common utils.
 /// Deserializes a `serde_json` object from slice with the recursion limit disabled.
 /// Must be used for all JSON I/O to avoid crashes due to the aforementioned limit.
 pub fn deserialize_from_slice<O>(input: &[u8]) -> anyhow::Result<O>
 where
    O: serde::de::DeserializeOwned,
 {
    let mut deserializer = serde_json::Deserializer::from_slice(input);
    deserializer.disable_recursion_limit();
    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
    let result = O::deserialize(deserializer)?;
    Ok(result)
 }
 /// Deserializes a `serde_json` object from string with the recursion limit disabled.
 /// Must be used for all JSON I/O to avoid crashes due to the aforementioned limit.
 pub fn deserialize_from_str<O>(input: &str) -> anyhow::Result<O>
 where
    O: serde::de::DeserializeOwned,
 {
    let mut deserializer = serde_json::Deserializer::from_str(input);
    deserializer.disable_recursion_limit();
    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
    let result = O::deserialize(deserializer)?;
    Ok(result)
 }
@@ -1,16 +0,0 @@
 [package]
 name = "revive-differential"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 authors.workspace = true
 repository.workspace = true
 [dependencies]
 hex = { workspace = true }
 tempfile = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 alloy-primitives = { workspace = true, features = ["serde"] }
 alloy-genesis = { workspace = true }
 alloy-serde = { workspace = true }
@@ -1,47 +0,0 @@
 {
    "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,
        "blobSchedule": {
            "cancun": {
                "target": 3,
                "max": 6,
                "baseFeeUpdateFraction": 3338477
            }
        }
    },
    "coinbase": "0xffffffffffffffffffffffffffffffffffffffff",
    "difficulty": "0x20000",
    "extraData": "",
    "gasLimit": "0xffffffff",
    "nonce": "0x0000000000000042",
    "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "timestamp": "0x00",
    "alloc": {
        "0101010101010101010101010101010101010101": {
            "balance": "1000000000"
        },
        "0202020202020202020202020202020202020202": {
            "balance": "1000000000"
        },
        "0303030303030303030303030303030303030303": {
            "balance": "1000000000"
        }
    }
 }
@@ -1,199 +0,0 @@
 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")),
        );
    }
 }
@@ -1,570 +0,0 @@
 use core::str;
 use std::{
    collections::BTreeMap,
    io::Write,
    path::PathBuf,
    process::{Command, Stdio},
    str::FromStr,
    time::Duration,
 };
 use alloy_genesis::{Genesis, GenesisAccount};
 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};
 pub use self::go_duration::parse_go_duration;
 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 From<StateDump> for Genesis {
    fn from(value: StateDump) -> Self {
        let mut genesis: Genesis = serde_json::from_str(GENESIS_JSON).unwrap();
        genesis.alloc = value
            .accounts
            .iter()
            .map(|(address, account)| (*address, account.clone().into()))
            .collect();
        genesis
    }
 }
 /// The geth EVM state dump account structure
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct Account {
    pub balance: U256,
    pub nonce: u64,
    pub code: Option<Bytes>,
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        deserialize_with = "deserialize_storage_map"
    )]
    pub storage: Option<BTreeMap<B256, B256>>,
    pub key: Option<B256>,
 }
 impl From<Account> for GenesisAccount {
    fn from(value: Account) -> Self {
        GenesisAccount {
            balance: value.balance,
            nonce: Some(value.nonce),
            code: value.code,
            storage: value.storage,
            private_key: value.key,
        }
    }
 }
 /// Contains the output from geth `emv` invocations
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub struct EvmOutput {
    pub output: Bytes,
    #[serde(rename = "gasUsed")]
    pub gas_used: U256,
    pub error: Option<String>,
 }
 impl EvmOutput {
    /// Return if there was no error found.
    ///
    /// Panics if the gas used is zero as this indicates nothing was run.
    pub fn run_success(&self) -> bool {
        assert_ne!(self.gas_used, U256::ZERO, "nothing was executed: {self:?}");
        self.error.is_none()
    }
 }
 /// Contains the full log from geth `emv` invocations
 #[derive(Clone, Debug)]
 pub struct EvmLog {
    pub account_deployed: Option<Address>,
    pub output: EvmOutput,
    pub state_dump: StateDump,
    pub stderr: String,
 }
 impl EvmLog {
    pub const EXECUTION_TIME_MARKER: &'static str = "execution time:";
    /// Parse the reported execution time from stderr (requires --bench)
    pub fn execution_time(&self) -> Result<Duration, String> {
        for line in self.stderr.lines() {
            if let Some(value) = line.split("execution time:").nth(1) {
                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()
            },
            state_dump: Default::default(),
            stderr: Default::default(),
        }
    }
 }
 /// 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);
        };
        // Dynamic args
        command.args(["--prestate", genesis_json_path]);
        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 = format!("{stdout}{stderr}").as_str().into();
        log.stderr = stderr.into();
        if self.bench {
            log.parse_gas_used_from_bench();
        }
        // Set the deployed account
        log.account_deployed = account_deployed;
        log
    }
 }
 #[cfg(test)]
 mod tests {
    use std::{str::FromStr, time::Duration};
    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]
    #[ignore] // https://github.com/ethereum/go-ethereum/issues/30778
    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));
    }
 }
@@ -1,23 +0,0 @@
 [package]
 name = "revive-integration"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors.workspace = true
 description = "revive compiler integration test cases"
 [dependencies]
 alloy-primitives = { workspace = true }
 alloy-sol-types = { workspace = true }
 hex = { workspace = true }
 serde_json = { workspace = true }
 revive-solidity = { workspace = true }
 revive-runner = { workspace = true }
 [dev-dependencies]
 sha1 = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 rayon = { workspace = true }
@@ -1,10 +0,0 @@
 {
  "Baseline": 1110,
  "Computation": 2389,
  "DivisionArithmetics": 14822,
  "ERC20": 23973,
  "Events": 1605,
  "FibonacciIterative": 2023,
  "Flipper": 1989,
  "SHA1": 17026
 }
@@ -1,81 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Upload": {
                "code": {
                    "Solidity": {
                        "contract": "BalanceReceiver"
                    }
                }
            }
        },
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "Balance"
                    }
                },
                "value": 24
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "1c8d16b30000000000000000000000000303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000a"
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "6ada15d90000000000000000000000000303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000a"
            }
        }
    ]
 }
 */
 contract BalanceReceiver {
    constructor() payable {}
    fallback() external payable {}
 }
 contract Balance {
    constructor() payable {
        // 0 to EOA
        transfer_to(payable(address(0xdeadbeef)), 0);
        send_to(payable(address(0xdeadbeef)), 0);
        // 1 to EOA
        transfer_to(payable(address(0xcafebabe)), 1);
        send_to(payable(address(0xcafebabe)), 1);
        BalanceReceiver balanceReceiver = new BalanceReceiver();
        // 0 to contract
        transfer_to(payable(address(balanceReceiver)), 0);
        send_to(payable(address(balanceReceiver)), 0);
        // 1 to contract
        transfer_to(payable(address(balanceReceiver)), 1);
        send_to(payable(address(balanceReceiver)), 1);
    }
    function transfer_to(address payable _dest, uint _amount) public payable {
        _dest.transfer(_amount);
    }
    function send_to(address payable _dest, uint _amount) public payable {
        require(_dest.send(_amount));
    }
 }
@@ -1,31 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "BaseFee"
                    }
                }
            }
        },
        {
            "VerifyCall": {
                "success": true
            }
        }
    ]
 }
 */
 contract BaseFee {
    constructor() payable {
        assert(block.basefee == 0);
    }
 }
@@ -1,22 +0,0 @@
 // SPDX-License-Identifier: MIT
 /* runner.json
 {
  "actions": [
    {
      "Instantiate": {
        "origin": "Alice",
        "value": 0
      }
    }
  ]
 }
 */
 pragma solidity ^0.8;
 contract Baseline {
    function baseline() public payable {}
 }
@@ -1,36 +0,0 @@
 // 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)
        }
    }
 }
@@ -1,50 +0,0 @@
 // SPDX-License-Identifier: MIT
 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;
        }
    }
 }
@@ -1,33 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "BlockHash"
                    }
                },
                "data": "4545454545454545454545454545454545454545454545454545454545454545"
            }
        }
    ]
 }
 */
 contract BlockHash {
    constructor(bytes32 expected) payable {
        assert(blockhash(0) == expected);
        assert(blockhash(1) == 0);
        assert(
            blockhash(
                0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
            ) == 0
        );
    }
 }
@@ -1,58 +0,0 @@
 // 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);
    }
 }
@@ -1,27 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "Coinbase"
                    }
                }
            }
        }
    ]
 }
 */
 contract Coinbase {
    constructor() payable {
        address coinbase = address(0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF);
        assert(block.coinbase == coinbase);
    }
 }
@@ -1,61 +0,0 @@
 // SPDX-License-Identifier: MIT
 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 {
            for (int64 x = 1; x <= n; x++) {
                sum += x;
            }
        }
    }
    function odd_product(int32 n) public pure returns (int64) {
        unchecked {
            int64 prod = 1;
            for (int32 x = 1; x <= n; x++) {
                prod *= 2 * int64(x) - 1;
            }
            return prod;
        }
    }
 }
@@ -1,62 +0,0 @@
 // SPDX-License-Identifier: MIT
 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);
    }
    function caller() public view returns (address ret) {
        ret = msg.sender;
    }
    function chain_id() public view returns (uint) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }
 }
@@ -1,72 +0,0 @@
 // 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"}();
    }
 }
@@ -1,50 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Upload": {
                "code": {
                    "Solidity": {
                        "contract": "CreateA"
                    }
                }
            }
        },
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "CreateB"
                    }
                },
                "value": 100000
            }
        }
    ]
 }
 */
 contract CreateA {
    constructor() payable {}
 }
 contract CreateB {
    constructor() payable {
        bytes32 salt = hex"ff";
        try new CreateA{salt: salt}() returns (CreateA) {} catch {
            revert("the first instantiation should succeed");
        }
        try new CreateA{salt: salt}() returns (CreateA) {} catch {
            return;
        }
        revert("the second instantiation should have failed");
    }
 }
@@ -1,35 +0,0 @@
 // 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);
    }
 }
@@ -1,84 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Upload": {
                "code": {
                    "Solidity": {
                        "contract": "Logic"
                    }
                }
            }
        },
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "Tester"
                    }
                }
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "value": 123,
                "data": "6466414b0000000000000000000000000000000000000000000000000000000000000020"
            }
        }
    ]
 }
 */
 contract Logic {
    // NOTE: storage layout must be the same as contract Tester
    uint256 public num;
    address public sender;
    uint256 public value;
    uint public immutable multiplier = 4;
    event DidSetVars();
    function setVars(uint256 _num) public payable returns (uint256) {
        num = _num * multiplier;
        sender = msg.sender;
        value = msg.value;
        emit DidSetVars();
        return _num;
    }
 }
 contract Tester {
    uint256 public num;
    address public sender;
    uint256 public value;
    uint public immutable multiplier = 2;
    function setVars(uint256 _num) public payable returns (bool, bytes memory) {
        Logic impl = new Logic();
        // Tester's storage is set, Logic is not modified.
        (bool success, bytes memory data) = address(impl).delegatecall(
            abi.encodeWithSignature("setVars(uint256)", _num)
        );
        assert(success);
        assert(impl.num() == 0);
        assert(impl.sender() == address(0));
        assert(impl.value() == 0);
        assert(num == _num * 4);
        assert(sender == msg.sender);
        assert(value == msg.value);
        return (success, data);
    }
 }
@@ -1,29 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 contract DivisionArithmetics {
    function div(uint n, uint d) public pure returns (uint q) {
        assembly {
            q := div(n, d)
        }
    }
    function sdiv(int n, int d) public pure returns (int q) {
        assembly {
            q := sdiv(n, d)
        }
    }
    function mod(uint n, uint d) public pure returns (uint r) {
        assembly {
            r := mod(n, d)
        }
    }
    function smod(int n, int d) public pure returns (int r) {
        assembly {
            r := smod(n, d)
        }
    }
 }
@@ -1,123 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Upload": {
                "code": {
                    "Solidity": {
                        "contract": "ERC20"
                    }
                }
            }
        },
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "ERC20Tester"
                    }
                }
            }
        }
    ]
 }
 */
 // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v3.0.0/contracts/token/ERC20/IERC20.sol
 interface IERC20 {
    function totalSupply() external view returns (uint);
    function balanceOf(address account) external view returns (uint);
    function transfer(address recipient, uint amount) external returns (bool);
    function allowance(
        address owner,
        address spender
    ) external view returns (uint);
    function approve(address spender, uint amount) external returns (bool);
    function transferFrom(
        address sender,
        address recipient,
        uint amount
    ) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
 }
 contract ERC20 is IERC20 {
    uint public totalSupply;
    mapping(address => uint) public balanceOf;
    mapping(address => mapping(address => uint)) public allowance;
    string public name = "Solidity by Example";
    string public symbol = "SOLBYEX";
    uint8 public decimals = 18;
    function transfer(address recipient, uint amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }
    function approve(address spender, uint amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }
    function transferFrom(
        address sender,
        address recipient,
        uint amount
    ) external returns (bool) {
        allowance[sender][msg.sender] -= amount;
        balanceOf[sender] -= amount;
        balanceOf[recipient] += amount;
        emit Transfer(sender, recipient, amount);
        return true;
    }
    function mint(uint amount) external {
        balanceOf[msg.sender] += amount;
        totalSupply += amount;
        emit Transfer(address(0), msg.sender, amount);
    }
    function burn(uint amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
        emit Transfer(msg.sender, address(0), amount);
    }
 }
 contract ERC20Tester {
    constructor() {
        address BOB = address(0xffffffffffffffffffffffffffffffffffffff);
        ERC20 token = new ERC20();
        assert(token.decimals() == 18);
        token.mint(300);
        assert(token.balanceOf(address(this)) == 300);
        token.transfer(BOB, 100);
        assert(token.balanceOf(address(this)) == 200);
        assert(token.balanceOf(BOB) == 100);
        token.approve(address(this), 100);
        token.transferFrom(address(this), BOB, 100);
        assert(token.balanceOf(BOB) == 200);
        assert(token.balanceOf(address(this)) == 100);
        token.burn(100);
        assert(token.balanceOf(address(this)) == 0);
    }
 }
@@ -1,49 +0,0 @@
 // SPDX-License-Identifier: MIT
 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);
    function emitEvent(uint topics) public {
        if (topics == 0) {
            emit A();
        } else {
            emit E(topics, 1, 2, 3);
        }
    }
 }
@@ -1,29 +0,0 @@
 // 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())
        }
    }
 }
@@ -1,90 +0,0 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8;
 /* 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) {
        if (n <= 1) {
            return n;
        } else {
            return f(n - 1) + f(n - 2);
        }
    }
    function fib3(uint n) public pure returns (uint) {
        return f(n);
    }
 }
 contract FibonacciIterative {
    function fib3(uint n) external pure returns (uint b) {
        if (n == 0) {
            return 0;
        }
        uint a = 1;
        b = 1;
        for (uint i = 2; i < n; i++) {
            unchecked {
                uint c = a + b;
                a = b;
                b = c;
            }
        }
        return b;
    }
 }
 // https://medium.com/coinmonks/fibonacci-in-solidity-8477d907e22a
 contract FibonacciBinet {
    function fib3(uint n) external pure returns (uint a) {
        if (n == 0) {
            return 0;
        }
        uint h = n / 2;
        uint mask = 1;
        // find highest set bit in n
        while (mask <= h) {
            mask <<= 1;
        }
        mask >>= 1;
        a = 1;
        uint b = 1;
        uint c;
        while (mask > 0) {
            c = a * a + b * b;
            if (n & mask > 0) {
                b = b * (b + 2 * a);
                a = c;
            } else {
                a = a * (2 * b - a);
                b = c;
            }
            mask >>= 1;
        }
        return a;
    }
 }
@@ -1,42 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "FunctionPointer"
                    }
                }
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "26121ff0"
            }
        }
    ]
 }
 */
 contract FunctionPointer {
    bool public flag = false;
    function f0() public {
        flag = true;
    }
    function f() public returns (bool) {
        function() internal x = f0;
        x();
        return flag;
    }
 }
@@ -1,32 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "GasLeft"
                    }
                }
            }
        },
        {
            "VerifyCall": {
                "success": true
            }
        }
    ]
 }
 */
 contract GasLeft {
    constructor() payable {
        assert(gasleft() > gasleft());
        assert(gasleft() > 0 && gasleft() < 0xffffffffffffffff);
    }
 }
@@ -1,31 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "GasLimit"
                    }
                }
            }
        },
        {
            "VerifyCall": {
                "success": true
            }
        }
    ]
 }
 */
 contract GasLimit {
    constructor() payable {
        assert(block.gaslimit == 2000000000000);
    }
 }
@@ -1,31 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "GasPrice"
                    }
                }
            }
        },
        {
            "VerifyCall": {
                "success": true
            }
        }
    ]
 }
 */
 contract GasPrice {
    constructor() payable {
        assert(tx.gasprice == 1000);
    }
 }
@@ -1,63 +0,0 @@
 // 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);
    }
 }
@@ -1,34 +0,0 @@
 // 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;
    }
 }
@@ -1,40 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "MLoad"
                    }
                }
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "e2179b8e"
            }
        }
    ]
 }
 */
 contract MLoad {
    constructor() payable {
        assert(g() == 0);
    }
    function g() public payable returns (uint m) {
        assembly {
            m := mload(0)
        }
    }
 }
@@ -1,54 +0,0 @@
 // SPDX-License-Identifier: MIT
 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;
    function mSize() public pure returns (uint size) {
        assembly {
            size := msize()
        }
    }
    function mStore100() public pure returns (uint size) {
        assembly {
            mstore(100, msize())
            size := msize()
        }
    }
 }
@@ -1,101 +0,0 @@
 // 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)
        }
    }
 }
@@ -1,53 +0,0 @@
 // 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)
        }
    }
 }
@@ -1,265 +0,0 @@
 // 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 {
            // Get a safe scratch location
            let scratch := mload(0x40)
            // Get the data length, and point data at the first byte
            let len := mload(data)
            data := add(data, 32)
            // Find the length after padding
            let totallen := add(and(add(len, 1), 0xFFFFFFFFFFFFFFC0), 64)
            switch lt(sub(totallen, len), 9)
            case 1 {
                totallen := add(totallen, 64)
            }
            let h := 0x6745230100EFCDAB890098BADCFE001032547600C3D2E1F0
            function readword(ptr, off, count) -> result {
                result := 0
                if lt(off, count) {
                    result := mload(add(ptr, off))
                    count := sub(count, off)
                    if lt(count, 32) {
                        let mask := not(sub(exp(256, sub(32, count)), 1))
                        result := and(result, mask)
                    }
                }
            }
            for {
                let i := 0
            } lt(i, totallen) {
                i := add(i, 64)
            } {
                mstore(scratch, readword(data, i, len))
                mstore(add(scratch, 32), readword(data, add(i, 32), len))
                // If we loaded the last byte, store the terminator byte
                switch lt(sub(len, i), 64)
                case 1 {
                    mstore8(add(scratch, sub(len, i)), 0x80)
                }
                // If this is the last block, store the length
                switch eq(i, sub(totallen, 64))
                case 1 {
                    mstore(
                        add(scratch, 32),
                        or(mload(add(scratch, 32)), mul(len, 8))
                    )
                }
                // Expand the 16 32-bit words into 80
                for {
                    let j := 64
                } lt(j, 128) {
                    j := add(j, 12)
                } {
                    let temp := xor(
                        xor(
                            mload(add(scratch, sub(j, 12))),
                            mload(add(scratch, sub(j, 32)))
                        ),
                        xor(
                            mload(add(scratch, sub(j, 56))),
                            mload(add(scratch, sub(j, 64)))
                        )
                    )
                    temp := or(
                        and(
                            mul(temp, 2),
                            0xFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFEFFFFFFFE
                        ),
                        and(
                            div(temp, 0x80000000),
                            0x0000000100000001000000010000000100000001000000010000000100000001
                        )
                    )
                    mstore(add(scratch, j), temp)
                }
                for {
                    let j := 128
                } lt(j, 320) {
                    j := add(j, 24)
                } {
                    let temp := xor(
                        xor(
                            mload(add(scratch, sub(j, 24))),
                            mload(add(scratch, sub(j, 64)))
                        ),
                        xor(
                            mload(add(scratch, sub(j, 112))),
                            mload(add(scratch, sub(j, 128)))
                        )
                    )
                    temp := or(
                        and(
                            mul(temp, 4),
                            0xFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFCFFFFFFFC
                        ),
                        and(
                            div(temp, 0x40000000),
                            0x0000000300000003000000030000000300000003000000030000000300000003
                        )
                    )
                    mstore(add(scratch, j), temp)
                }
                let x := h
                let f := 0
                let k := 0
                for {
                    let j := 0
                } lt(j, 80) {
                    j := add(j, 1)
                } {
                    switch div(j, 20)
                    case 0 {
                        // f = d xor (b and (c xor d))
                        f := xor(
                            div(x, 0x100000000000000000000),
                            div(x, 0x10000000000)
                        )
                        f := and(div(x, 0x1000000000000000000000000000000), f)
                        f := xor(div(x, 0x10000000000), f)
                        k := 0x5A827999
                    }
                    case 1 {
                        // f = b xor c xor d
                        f := xor(
                            div(x, 0x1000000000000000000000000000000),
                            div(x, 0x100000000000000000000)
                        )
                        f := xor(div(x, 0x10000000000), f)
                        k := 0x6ED9EBA1
                    }
                    case 2 {
                        // f = (b and c) or (d and (b or c))
                        f := or(
                            div(x, 0x1000000000000000000000000000000),
                            div(x, 0x100000000000000000000)
                        )
                        f := and(div(x, 0x10000000000), f)
                        f := or(
                            and(
                                div(x, 0x1000000000000000000000000000000),
                                div(x, 0x100000000000000000000)
                            ),
                            f
                        )
                        k := 0x8F1BBCDC
                    }
                    case 3 {
                        // f = b xor c xor d
                        f := xor(
                            div(x, 0x1000000000000000000000000000000),
                            div(x, 0x100000000000000000000)
                        )
                        f := xor(div(x, 0x10000000000), f)
                        k := 0xCA62C1D6
                    }
                    // temp = (a leftrotate 5) + f + e + k + w[i]
                    let temp := and(
                        div(
                            x,
                            0x80000000000000000000000000000000000000000000000
                        ),
                        0x1F
                    )
                    temp := or(
                        and(
                            div(x, 0x800000000000000000000000000000000000000),
                            0xFFFFFFE0
                        ),
                        temp
                    )
                    temp := add(f, temp)
                    temp := add(and(x, 0xFFFFFFFF), temp)
                    temp := add(k, temp)
                    temp := add(
                        div(
                            mload(add(scratch, mul(j, 4))),
                            0x100000000000000000000000000000000000000000000000000000000
                        ),
                        temp
                    )
                    x := or(
                        div(x, 0x10000000000),
                        mul(temp, 0x10000000000000000000000000000000000000000)
                    )
                    x := or(
                        and(
                            x,
                            0xFFFFFFFF00FFFFFFFF000000000000FFFFFFFF00FFFFFFFF
                        ),
                        mul(
                            or(
                                and(div(x, 0x4000000000000), 0xC0000000),
                                and(div(x, 0x400000000000000000000), 0x3FFFFFFF)
                            ),
                            0x100000000000000000000
                        )
                    )
                }
                h := and(
                    add(h, x),
                    0xFFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF00FFFFFFFF
                )
            }
            ret := mul(
                or(
                    or(
                        or(
                            or(
                                and(
                                    div(h, 0x100000000),
                                    0xFFFFFFFF00000000000000000000000000000000
                                ),
                                and(
                                    div(h, 0x1000000),
                                    0xFFFFFFFF000000000000000000000000
                                )
                            ),
                            and(div(h, 0x10000), 0xFFFFFFFF0000000000000000)
                        ),
                        and(div(h, 0x100), 0xFFFFFFFF00000000)
                    ),
                    and(h, 0xFFFFFFFF)
                ),
                0x1000000000000000000000000
            )
        }
    }
 }
@@ -1,75 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "Send"
                    }
                },
                "value": 211
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "1c8d16b30000000000000000000000000303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000a"
            }
        },
        {
            "VerifyCall": {
                "success": true
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "fb9e8d050000000000000000000000000000000000000000000000000000000000000001"
            }
        },
        {
            "VerifyCall": {
                "success": false
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "fb9e8d050000000000000000000000000000000000000000000000000000000000000000"
            }
        },
        {
            "VerifyCall": {
                "success": false
            }
        }
    ]
 }
 */
 contract Send {
    constructor() payable {}
    function transfer_self(uint _amount) public payable {
        transfer_to(payable(address(this)), _amount);
    }
    function transfer_to(address payable _dest, uint _amount) public payable {
        if (_dest.send(_amount)) {}
    }
    fallback() external {}
    receive() external payable {}
 }
@@ -1,55 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "Storage"
                    }
                }
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "fabc9efaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "558b9f9bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
            }
        }
    ]
 }
 */
 contract Storage {
    function transient(uint value) public returns (uint ret) {
        assembly {
            let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
            tstore(slot, value)
            let success := call(0, 0, 0, 0, 0, 0, 0)
            ret := tload(slot)
        }
    }
    function persistent(uint value) public returns (uint ret) {
        assembly {
            let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
            sstore(slot, value)
            ret := sload(slot)
        }
    }
 }
@@ -1,54 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 /* runner.json
 {
    "differential": true,
    "actions": [
        {
            "Upload": {
                "code": {
                    "Solidity": {
                        "contract": "TransactionOrigin"
                    }
                }
            }
        },
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "TransactionTester"
                    }
                }
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "f8a8fd6d"
            }
        }
    ]
 }
 */
 contract TransactionTester {
    constructor() payable {
        assert(tx.origin == new TransactionOrigin().test());
    }
    function test() public payable returns (address ret) {
        ret = tx.origin;
    }
 }
 contract TransactionOrigin {
    function test() public payable returns (address ret) {
        assert(msg.sender != tx.origin);
        ret = tx.origin;
    }
 }
@@ -1,75 +0,0 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8;
 /* runner.json
 {
    "differential": false,
    "actions": [
        {
            "Instantiate": {
                "code": {
                    "Solidity": {
                        "contract": "Transfer"
                    }
                },
                "value": 211
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "1c8d16b30000000000000000000000000303030303030303030303030303030303030303000000000000000000000000000000000000000000000000000000000000000a"
            }
        },
        {
            "VerifyCall": {
                "success": true
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "fb9e8d050000000000000000000000000000000000000000000000000000000000000001"
            }
        },
        {
            "VerifyCall": {
                "success": false
            }
        },
        {
            "Call": {
                "dest": {
                    "Instantiated": 0
                },
                "data": "fb9e8d050000000000000000000000000000000000000000000000000000000000000000"
            }
        },
        {
            "VerifyCall": {
                "success": false
            }
        }
    ]
 }
 */
 contract Transfer {
    constructor() payable {}
    function transfer_self(uint _amount) public payable {
        transfer_to(payable(address(this)), _amount);
    }
    function transfer_to(address payable _dest, uint _amount) public payable {
        _dest.transfer(_amount);
    }
    fallback() external {}
    receive() external payable {}
 }
@@ -1,66 +0,0 @@
 // 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;
    }
 }
@@ -1,52 +0,0 @@
 // 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;
    }
 }
@@ -1,322 +0,0 @@
 use alloy_primitives::{Address, Bytes, I256, U256};
 use alloy_sol_types::{sol, SolCall, SolConstructor};
 use revive_solidity::test_utils::*;
 #[derive(Clone)]
 pub struct Contract {
    pub name: &'static str,
    pub evm_runtime: Vec<u8>,
    pub pvm_runtime: Vec<u8>,
    pub calldata: Vec<u8>,
 }
 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)
            }
        }
    };
    // 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!(
    contract ERC20 {
        function totalSupply() external view returns (uint);
        function balanceOf(address account) external view returns (uint);
        function transfer(address recipient, uint amount) external returns (bool);
        function allowance(
            address owner,
            address spender
        ) external view returns (uint);
        function approve(address spender, uint amount) external returns (bool);
        function transferFrom(
            address sender,
            address recipient,
            uint amount
        ) external returns (bool);
        event Transfer(address indexed from, address indexed to, uint value);
        event Approval(address indexed owner, address indexed spender, uint value);
    }
 );
 case!("ERC20.sol", ERC20, totalSupplyCall, erc20,);
 sol!(
    contract Block {
        function timestamp() public view returns (uint ret);
        function number() public view returns (uint ret);
    }
 );
 case!("Block.sol", Block, numberCall, block_number,);
 case!("Block.sol", Block, timestampCall, block_timestamp,);
 sol!(
    contract Context {
        function address_this() public view returns (address);
        function caller() public pure returns (address);
    }
 );
 case!("Context.sol", Context, address_thisCall, context_address,);
 case!("Context.sol", Context, callerCall, context_caller,);
 sol!(
    contract DivisionArithmetics {
        function div(uint n, uint d) public pure returns (uint q);
        function sdiv(int n, int d) public pure returns (int q);
        function mod(uint n, uint d) public pure returns (uint r);
        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 Send {
        function transfer_self(uint _amount) public payable;
    }
 );
 case!("Send.sol", Send, transfer_selfCall, send_self, amount: U256);
 sol!(
    contract Transfer {
        function transfer_self(uint _amount) public payable;
    }
 );
 case!("Transfer.sol", Transfer, transfer_selfCall, transfer_self, amount: U256);
 sol!(
    contract MStore8 {
        function mStore8(uint value) public pure returns (uint256 word);
    }
 );
 case!("MStore8.sol", MStore8, mStore8Call, mstore8, value: U256);
 sol!(
    contract Events {
        event A(uint) anonymous;
        event E(uint indexed, uint indexed, uint indexed);
        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 {
    fn build(calldata: Vec<u8>, name: &'static str, code: &str) -> Self {
        Self {
            name,
            evm_runtime: compile_evm_bin_runtime(name, code),
            pvm_runtime: compile_blob(name, code),
            calldata,
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use alloy_primitives::{Bytes, U256};
    use rayon::iter::{IntoParallelIterator, ParallelIterator};
    use serde::{de::Deserialize, Serialize};
    use std::{collections::BTreeMap, fs::File};
    use super::Contract;
    #[test]
    fn codesize() {
        let path = "codesize.json";
        let existing = File::open(path)
            .map(|file| {
                BTreeMap::<String, usize>::deserialize(&mut serde_json::Deserializer::from_reader(
                    file,
                ))
                .expect("should be able to deserialze codesize data")
            })
            .ok();
        let extract_code_size = |compile: fn() -> Contract| {
            let contract = compile();
            let contract_length = contract.pvm_runtime.len();
            let size_change = existing
                .as_ref()
                .and_then(|map| map.get(contract.name))
                .filter(|old| **old != 0)
                .map(|old| {
                    let old = *old as f32;
                    let p = (contract_length as f32 - old) / old * 100.0;
                    format!("({p}% change from {old} bytes)",)
                })
                .unwrap_or_default();
            println!("{}: {contract_length} bytes {size_change}", contract.name);
            (contract.name, contract_length)
        };
        [
            Contract::baseline as fn() -> Contract,
            Contract::flipper as fn() -> Contract,
            (|| Contract::odd_product(0)) as fn() -> Contract,
            (|| Contract::fib_iterative(U256::ZERO)) as fn() -> Contract,
            Contract::erc20 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,
        ]
        .into_par_iter()
        .map(extract_code_size)
        .collect::<BTreeMap<_, _>>()
        .serialize(&mut serde_json::Serializer::pretty(
            File::create(path).unwrap(),
        ))
        .unwrap_or_else(|err| panic!("can not write codesize data to '{path}': {err}"));
    }
 }
@@ -1,4 +0,0 @@
 pub mod cases;
 #[cfg(test)]
 mod tests;
@@ -1,484 +0,0 @@
 use std::str::FromStr;
 use alloy_primitives::*;
 use revive_runner::*;
 use SpecsAction::*;
 use crate::cases::Contract;
 /// Parameters:
 /// - The function name of the test
 /// - The contract name to fill in empty code based on the file path
 /// - The contract source file
 macro_rules! test_spec {
    ($test_name:ident, $contract_name:literal, $source_file:literal) => {
        #[test]
        fn $test_name() {
            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_spec!(baseline, "Baseline", "Baseline.sol");
 test_spec!(flipper, "Flipper", "flipper.sol");
 test_spec!(fibonacci_recursive, "FibonacciRecursive", "Fibonacci.sol");
 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!(value, "Value", "Value.sol");
 test_spec!(create, "CreateB", "Create.sol");
 test_spec!(call, "Caller", "Call.sol");
 test_spec!(balance, "Balance", "Balance.sol");
 test_spec!(return_data_oob, "ReturnDataOob", "ReturnDataOob.sol");
 test_spec!(immutables, "Immutables", "Immutables.sol");
 test_spec!(transaction, "Transaction", "Transaction.sol");
 test_spec!(block_hash, "BlockHash", "BlockHash.sol");
 test_spec!(delegate, "Delegate", "Delegate.sol");
 test_spec!(gas_price, "GasPrice", "GasPrice.sol");
 test_spec!(gas_left, "GasLeft", "GasLeft.sol");
 test_spec!(gas_limit, "GasLimit", "GasLimit.sol");
 test_spec!(base_fee, "BaseFee", "BaseFee.sol");
 test_spec!(coinbase, "Coinbase", "Coinbase.sol");
 test_spec!(create2, "CreateB", "Create2.sol");
 test_spec!(transfer, "Transfer", "Transfer.sol");
 test_spec!(send, "Send", "Send.sol");
 test_spec!(function_pointer, "FunctionPointer", "FunctionPointer.sol");
 test_spec!(mload, "MLoad", "MLoad.sol");
 fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
    vec![Instantiate {
        origin: TestAddress::Alice,
        value: 0,
        gas_limit: Some(GAS_LIMIT),
        storage_deposit_limit: None,
        code: Code::Solidity {
            path: Some(path.into()),
            contract: contract.to_string(),
            solc_optimizer: None,
        },
        data: vec![],
        salt: OptionalHex::default(),
    }]
 }
 fn run_differential(actions: Vec<SpecsAction>) {
    Specs {
        differential: true,
        actions,
        ..Default::default()
    }
    .run();
 }
 #[test]
 fn bitwise_byte() {
    let mut actions = instantiate("contracts/Bitwise.sol", "Bitwise");
    let de_bruijn_sequence =
        hex::decode("4060503824160d0784426150b864361d0f88c4a27148ac5a2f198d46e391d8f4").unwrap();
    let value = U256::from_be_bytes::<32>(de_bruijn_sequence.clone().try_into().unwrap());
    for input in de_bruijn_sequence
        .iter()
        .enumerate()
        .map(|(index, _)| Contract::bitwise_byte(U256::from(index), value).calldata)
        .chain([
            Contract::bitwise_byte(U256::ZERO, U256::ZERO).calldata,
            Contract::bitwise_byte(U256::ZERO, U256::MAX).calldata,
            Contract::bitwise_byte(U256::MAX, U256::ZERO).calldata,
            Contract::bitwise_byte(U256::from_str("18446744073709551619").unwrap(), U256::MAX)
                .calldata,
        ])
    {
        actions.push(Call {
            origin: TestAddress::Alice,
            dest: TestAddress::Instantiated(0),
            value: 0,
            gas_limit: None,
            storage_deposit_limit: None,
            data: input,
        })
    }
    run_differential(actions);
 }
 #[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 (n, d) in [
        (five, five),
        (five, one),
        (U256::ZERO, U256::MAX),
        (five, two),
        (one, U256::ZERO),
    ] {
        actions.push(Call {
            origin: TestAddress::Alice,
            dest: TestAddress::Instantiated(0),
            value: 0,
            gas_limit: None,
            storage_deposit_limit: None,
            data: Contract::division_arithmetics_div(n, d).calldata,
        })
    }
    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 (n, d) in [
        (five, five),
        (five, one),
        (I256::ZERO, I256::MAX),
        (I256::ZERO, I256::MINUS_ONE),
        (five, two),
        (five, I256::MINUS_ONE),
        (I256::MINUS_ONE, minus_two),
        (minus_five, minus_five),
        (minus_five, two),
        (I256::MINUS_ONE, I256::MIN),
        (one, I256::ZERO),
    ] {
        actions.push(Call {
            origin: TestAddress::Alice,
            dest: TestAddress::Instantiated(0),
            value: 0,
            gas_limit: None,
            storage_deposit_limit: None,
            data: Contract::division_arithmetics_sdiv(n, d).calldata,
        })
    }
    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 (n, d) in [
        (five, five),
        (five, one),
        (U256::ZERO, U256::MAX),
        (U256::MAX, U256::MAX),
        (five, two),
        (two, five),
        (U256::MAX, U256::ZERO),
    ] {
        actions.push(Call {
            origin: TestAddress::Alice,
            dest: TestAddress::Instantiated(0),
            value: 0,
            gas_limit: None,
            storage_deposit_limit: None,
            data: Contract::division_arithmetics_mod(n, d).calldata,
        })
    }
    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 (n, d) in [
        (five, five),
        (five, one),
        (I256::ZERO, I256::MAX),
        (I256::MAX, I256::MAX),
        (five, two),
        (two, five),
        (five, minus_five),
        (five, I256::MINUS_ONE),
        (five, minus_two),
        (minus_five, two),
        (minus_two, five),
        (minus_five, minus_five),
        (minus_five, I256::MINUS_ONE),
        (minus_five, minus_two),
        (minus_two, minus_five),
        (I256::MIN, I256::MINUS_ONE),
        (I256::ZERO, I256::ZERO),
    ] {
        actions.push(Call {
            origin: TestAddress::Alice,
            dest: TestAddress::Instantiated(0),
            value: 0,
            gas_limit: None,
            storage_deposit_limit: None,
            data: Contract::division_arithmetics_smod(n, d).calldata,
        })
    }
    run_differential(actions);
 }
 #[test]
 fn ext_code_hash() {
    let mut actions = instantiate("contracts/ExtCode.sol", "ExtCode");
    // 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();
 }
 #[test]
 fn ext_code_size() {
    let alice = Address::from(ALICE.0);
    let own_address = alice.create(0);
    let baseline_address = alice.create2([0u8; 32], keccak256(Contract::baseline().pvm_runtime));
    let own_code_size = U256::from(
        Contract::ext_code_size(Default::default())
            .pvm_runtime
            .len(),
    );
    let baseline_code_size = U256::from(Contract::baseline().pvm_runtime.len());
    Specs {
        actions: vec![
            // Instantiate the test contract
            instantiate("contracts/ExtCode.sol", "ExtCode").remove(0),
            // Instantiate the baseline contract
            Instantiate {
                origin: TestAddress::Alice,
                value: 0,
                gas_limit: Some(GAS_LIMIT),
                storage_deposit_limit: None,
                code: Code::Solidity {
                    path: Some("contracts/Baseline.sol".into()),
                    contract: "Baseline".to_string(),
                    solc_optimizer: None,
                },
                data: vec![],
                salt: OptionalHex::from([0; 32]),
            },
            // Alice is not a contract and returns a code size of 0
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value: 0,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::ext_code_size(alice).calldata,
            },
            VerifyCall(VerifyCallExpectation {
                success: true,
                output: OptionalHex::from([0u8; 32].to_vec()),
                gas_consumed: None,
            }),
            // Unknown address returns a code size of 0
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value: 0,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::ext_code_size(Address::from([0xff; 20])).calldata,
            },
            VerifyCall(VerifyCallExpectation {
                success: true,
                output: OptionalHex::from([0u8; 32].to_vec()),
                gas_consumed: None,
            }),
            // Own address via extcodesize returns own code size
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value: 0,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::ext_code_size(own_address).calldata,
            },
            VerifyCall(VerifyCallExpectation {
                success: true,
                output: OptionalHex::from(own_code_size.to_be_bytes::<32>().to_vec()),
                gas_consumed: None,
            }),
            // Own address via codesize returns own code size
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value: 0,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::code_size().calldata,
            },
            VerifyCall(VerifyCallExpectation {
                success: true,
                output: OptionalHex::from(own_code_size.to_be_bytes::<32>().to_vec()),
                gas_consumed: None,
            }),
            // Baseline address returns the baseline code size
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value: 0,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::ext_code_size(baseline_address).calldata,
            },
            VerifyCall(VerifyCallExpectation {
                success: true,
                output: OptionalHex::from(baseline_code_size.to_be_bytes::<32>().to_vec()),
                gas_consumed: None,
            }),
        ],
        ..Default::default()
    }
    .run();
 }
 #[test]
 #[should_panic(expected = "ReentranceDenied")]
 fn send_denies_reentrancy() {
    let value = 1000;
    Specs {
        actions: vec![
            instantiate("contracts/Send.sol", "Send").remove(0),
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::send_self(U256::from(value)).calldata,
            },
        ],
        differential: false,
        ..Default::default()
    }
    .run();
 }
 #[test]
 #[should_panic(expected = "ReentranceDenied")]
 fn transfer_denies_reentrancy() {
    let value = 1000;
    Specs {
        actions: vec![
            instantiate("contracts/Transfer.sol", "Transfer").remove(0),
            Call {
                origin: TestAddress::Alice,
                dest: TestAddress::Instantiated(0),
                value,
                gas_limit: None,
                storage_deposit_limit: None,
                data: Contract::transfer_self(U256::from(value)).calldata,
            },
        ],
        differential: false,
        ..Default::default()
    }
    .run();
 }
@@ -1,17 +0,0 @@
 [package]
 name = "revive-linker"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors.workspace = true
 description = "revive compiler linker utils"
 [dependencies]
 tempfile = { workspace = true }
 polkavm-linker = { workspace = true }
 libc = { workspace = true }
 anyhow = { workspace = true }
 revive-builtins = { workspace = true }
 lld-sys = { workspace = true }
@@ -1,77 +0,0 @@
 use std::{env, ffi::CString, fs};
 use lld_sys::LLDELFLink;
 use revive_builtins::COMPILER_RT;
 const LINKER_SCRIPT: &str = r#"
 SECTIONS {
    .text : { KEEP(*(.text.polkavm_export)) *(.text .text.*) }
 }"#;
 const BUILTINS_ARCHIVE_FILE: &str = "libclang_rt.builtins-riscv64.a";
 const BUILTINS_LIB_NAME: &str = "clang_rt.builtins-riscv64";
 fn invoke_lld(cmd_args: &[&str]) -> bool {
    let c_strings = cmd_args
        .iter()
        .map(|arg| CString::new(*arg).expect("ld.lld args should not contain null bytes"))
        .collect::<Vec<_>>();
    let args: Vec<*const libc::c_char> = c_strings.iter().map(|arg| arg.as_ptr()).collect();
    unsafe { LLDELFLink(args.as_ptr(), args.len()) == 0 }
 }
 pub fn polkavm_linker<T: AsRef<[u8]>>(code: T, strip_binary: bool) -> anyhow::Result<Vec<u8>> {
    let mut config = polkavm_linker::Config::default();
    config.set_strip(strip_binary);
    config.set_optimize(true);
    polkavm_linker::program_from_elf(config, code.as_ref())
        .map_err(|reason| anyhow::anyhow!("polkavm linker failed: {}", reason))
 }
 pub fn link<T: AsRef<[u8]>>(input: T) -> anyhow::Result<Vec<u8>> {
    let dir = tempfile::tempdir().expect("failed to create temp directory for linking");
    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(BUILTINS_ARCHIVE_FILE);
    fs::write(&object_path, input).map_err(|msg| anyhow::anyhow!("{msg} {object_path:?}"))?;
    if env::var("PVM_LINKER_DUMP_OBJ").is_ok() {
        fs::copy(&object_path, "/tmp/out.o")?;
    }
    fs::write(&linker_script_path, LINKER_SCRIPT)
        .map_err(|msg| anyhow::anyhow!("{msg} {linker_script_path:?}"))?;
    fs::write(&compiler_rt_path, COMPILER_RT)
        .map_err(|msg| anyhow::anyhow!("{msg} {compiler_rt_path:?}"))?;
    let ld_args = [
        "ld.lld",
        "--lto=full",
        "--error-limit=0",
        "--relocatable",
        "--emit-relocs",
        "--no-relax",
        "--unique",
        "--gc-sections",
        "--library-path",
        dir.path().to_str().expect("should be utf8"),
        "--library",
        BUILTINS_LIB_NAME,
        linker_script_path.to_str().expect("should be utf8"),
        object_path.to_str().expect("should be utf8"),
        "-o",
        output_path.to_str().expect("should be utf8"),
    ];
    if invoke_lld(&ld_args) {
        return Err(anyhow::anyhow!("ld.lld failed"));
    }
    Ok(fs::read(&output_path)?)
 }
@@ -1,16 +0,0 @@
 [package]
 name = "lld-sys"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 authors.workspace = true
 build = "build.rs"
 description = "bindings for ld.lld core"
 [dependencies]
 libc = { workspace = true }
 [build-dependencies]
 cc = { workspace = true }
 revive-build-utils = { workspace = true }
@@ -1,107 +0,0 @@
 fn set_rustc_link_flags() {
    let llvm_lib_path = match std::env::var(revive_build_utils::REVIVE_LLVM_TARGET_PREFIX) {
        Ok(path) => std::path::PathBuf::from(path).join("lib"),
        _ => revive_build_utils::llvm_lib_dir(),
    };
    println!(
        "cargo:rustc-link-search=native={}",
        llvm_lib_path.to_string_lossy()
    );
    for lib in [
        // These are required by ld.lld
        "lldELF",
        "lldCommon",
        "lldMachO",
        "LLVMSupport",
        "LLVMLinker",
        "LLVMCore",
        "LLVMLTO",
        "LLVMTargetParser",
        "LLVMBinaryFormat",
        "LLVMDemangle",
        // The `llvm-sys` crate relies on `llvm-config` to obtain a list of required LLVM libraries
        // during the build process. This works well in typical native environments, where `llvm-config`
        // can accurately list the necessary libraries.
        // However, when cross-compiling to WebAssembly using Emscripten, `llvm-config` fails to recognize
        // JavaScript-based libraries, making it necessary to manually inject the required dependencies.
        "LLVMRISCVDisassembler",
        "LLVMRISCVAsmParser",
        "LLVMRISCVCodeGen",
        "LLVMRISCVDesc",
        "LLVMRISCVInfo",
        "LLVMExecutionEngine",
        "LLVMOption",
        "LLVMMCDisassembler",
        "LLVMPasses",
        "LLVMHipStdPar",
        "LLVMCFGuard",
        "LLVMCoroutines",
        "LLVMipo",
        "LLVMVectorize",
        "LLVMInstrumentation",
        "LLVMFrontendOpenMP",
        "LLVMFrontendOffloading",
        "LLVMGlobalISel",
        "LLVMAsmPrinter",
        "LLVMSelectionDAG",
        "LLVMCodeGen",
        "LLVMTarget",
        "LLVMObjCARCOpts",
        "LLVMCodeGenTypes",
        "LLVMIRPrinter",
        "LLVMScalarOpts",
        "LLVMInstCombine",
        "LLVMAggressiveInstCombine",
        "LLVMTransformUtils",
        "LLVMBitWriter",
        "LLVMAnalysis",
        "LLVMProfileData",
        "LLVMDebugInfoDWARF",
        "LLVMObject",
        "LLVMMCParser",
        "LLVMIRReader",
        "LLVMAsmParser",
        "LLVMMC",
        "LLVMDebugInfoCodeView",
        "LLVMBitReader",
        "LLVMRemarks",
        "LLVMBitstreamReader",
    ] {
        println!("cargo:rustc-link-lib=static={lib}");
    }
    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
    let target_env = std::env::var("CARGO_CFG_TARGET_ENV").unwrap_or_default();
    if target_os == "linux" {
        if target_env == "musl" {
            println!("cargo:rustc-link-lib=static=c++");
        } else {
            println!("cargo:rustc-link-lib=dylib=stdc++");
        }
    }
 }
 fn main() {
    println!(
        "cargo:rerun-if-env-changed={}",
        revive_build_utils::REVIVE_LLVM_HOST_PREFIX
    );
    println!(
        "cargo:rerun-if-env-changed={}",
        revive_build_utils::REVIVE_LLVM_TARGET_PREFIX
    );
    revive_build_utils::llvm_cxx_flags()
        .split_whitespace()
        .fold(&mut cc::Build::new(), |builder, flag| builder.flag(flag))
        .flag("-Wno-unused-parameter")
        .cpp(true)
        .file("src/linker.cpp")
        .compile("liblinker.a");
    set_rustc_link_flags();
    println!("cargo:rerun-if-changed=build.rs");
 }
@@ -1,3 +0,0 @@
 extern "C" {
    pub fn LLDELFLink(args: *const *const libc::c_char, size: libc::size_t) -> libc::c_int;
 }
@@ -1,22 +0,0 @@
 #include "lld/Common/Driver.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 LLD_HAS_DRIVER(elf);
 extern "C" bool LLDELFLink(const char *argv[], size_t length)
 {
    bool canRunAgain;
    {
        llvm::ArrayRef<const char *> args(argv, length);
        llvm::CrashRecoveryContext crc;
        if (!crc.RunSafely([&]()
                           { canRunAgain = lld::elf::link(args, llvm::outs(), llvm::errs(), false, false); }))
            return false;
    }
    llvm::CrashRecoveryContext crc;
    return canRunAgain && crc.RunSafely([&]()
                                        { lld::CommonLinkerContext::destroy(); });
 }
@@ -1,38 +0,0 @@
 [package]
 name = "revive-llvm-builder"
 description = "revive LLVM compiler framework builder"
 authors = [
    "Oleksandr Zarudnyi <a.zarudnyy@matterlabs.dev>",
    "Anton Baliasnikov <aba@matterlabs.dev>",
    "Cyrill Leutwiler <cyrill@parity.io>",
 ]
 version.workspace = true
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
 [[bin]]
 name = "revive-llvm"
 path = "src/revive_llvm/main.rs"
 [lib]
 doctest = false
 [dependencies]
 clap = { workspace = true, features = ["help", "std", "derive"] }
 anyhow = { workspace = true }
 serde = { workspace = true, features = [ "derive" ] }
 toml = { workspace = true }
 num_cpus = { workspace = true }
 fs_extra = { workspace = true }
 path-slash = { workspace = true }
 regex = { workspace = true }
 downloader = { workspace = true }
 tar = { workspace = true }
 flate2 = { workspace = true }
 env_logger = { workspace = true }
 log = { workspace = true }
 [dev-dependencies]
 assert_cmd = { workspace = true }
 assert_fs = { workspace = true }
@@ -1,132 +0,0 @@
 # revive LLVM builder
 Parity fork of the [Matter Labs zksync LLVM builder](https://github.com/matter-labs/era-compiler-llvm-builder) helper utility for compiling [revive](https://github.com/paritytech/revive) compatible LLVM builds.
 ## Installation and usage
 The LLVM compiler framework for revive must be built with our tool called `revive-llvm`.
 This is because the revive compiler has requirements not fullfilled in upstream builds:
 - Special builds for compiling the frontend into statically linked ELF binaries and also Wasm executables
 - The RISC-V target (the PolkaVM target)
 - The compiler-rt builtins for the PolkaVM target
 - We want to leave the assertions always on
 - Various other specific configurations and optimization may be applied
 Obtain a compatible build for your host platform from the release section of this repository (TODO). Alternatively follow below steps to get a custom build:
 <details>
 <summary>1. Install the system prerequisites.</summary>
   * Linux (Debian):
      Install the following packages:
      ```shell
      apt install cmake ninja-build curl git libssl-dev pkg-config clang lld
      ```
   * Linux (Arch):
      Install the following packages:
      ```shell
      pacman -Syu which cmake ninja curl git pkg-config clang lld
      ```
   * MacOS:
      * Install the [HomeBrew](https://brew.sh) package manager.
      * Install the following packages:
         ```shell
         brew install cmake ninja coreutils
         ```
      * Install your choice of a recent LLVM/[Clang](https://clang.llvm.org) compiler, e.g. via [Xcode](https://developer.apple.com/xcode/), [Apple’s Command Line Tools](https://developer.apple.com/library/archive/technotes/tn2339/_index.html), or your preferred package manager.
 </details>
 <details>
 <summary>2. Install Rust.</summary>
   * Follow the latest [official instructions](https://www.rust-lang.org/tools/install:
      ```shell
      curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
      . ${HOME}/.cargo/env
      ```
      > Currently we are not pinned to any specific version of Rust, so just install the latest stable build for your   platform.
 </details>
 <details>
 <summary>3. Install the revive LLVM framework builder.</summary>
   * Install the builder using `cargo`:
      ```shell
      cargo install --git https://github.com/paritytech/revive-llvm-builder --force --locked
      ```
      > The builder is not the LLVM framework itself, but a tool that clones its repository and runs a sequence of build commands. By default it is installed in `~/.cargo/bin/`, which is recommended to be added to your `$PATH`.
 </details>
 <details>
 <summary>4. (Optional) Create the `LLVM.lock` file.</summary>
   * The `LLVM.lock` dictates the LLVM source tree being used.
     A default `./LLVM.lock` pointing to the release used for development is already provided.
 </details>
 <details>
 <summary>5. Build LLVM.</summary>
   * Clone and build the LLVM framework using the `revive-llvm` tool.
     The clang and lld projects are required for the `resolc` Solidity frontend executable; they are enabled by default. LLVM assertions are also enabled by default.
      ```shell
      revive-llvm clone
      revive-llvm build --llvm-projects lld --llvm-projects clang
      ```
      Build artifacts end up in the `./target-llvm/gnu/target-final/` directory by default.
      The `gnu` directory depends on the supported archticture and will either be `gnu`, `musl` or `emscripten`.
      You now need to export the final target directory `$LLVM_SYS_181_PREFIX`: `export LLVM_SYS_181_PREFIX=${PWD}/target-llvm/gnu/target-final`
      If built with the `--enable-tests` option, test tools will be in the `./target-llvm/gnu/build-final/` directory, along with copies of the build artifacts. For all supported build options, run `revive-llvm build --help`.
 </details>
 ## Supported target architectures
 The following target platforms are supported:
 - Linux GNU (x86)
 - Linux MUSL (x86)
 - MacOS (aarch64)
 - Windows GNU (x86)
 - Emscripten (wasm32)
 <details>
 <summary>Building for MUSL</summary>
   * Via a musl build we can build revive into fully static ELF binaries.
     Which is desirable for reproducible Solidity contracts builds.
     The resulting binary is also very portable, akin to the`solc` frontend binary distribution.
     Clone and build the LLVM framework using the `revive-llvm` tool:
      ```shell
      revive-llvm --target-env musl clone
      revive-llvm --target-env musl build --enable-assertions --llvm-projects clang --llvm-projects lld 
      ```
 </details>
 <details>
 <summary>Building for Emscripten</summary>
   * Via an emsdk build we can run revive in the browser and on node.js.
     Clone and build the LLVM framework using the `revive-llvm` tool:
      ```shell
      revive-llvm --target-env emscripten clone
      revive-llvm --target-env emscripten build --enable-assertions --llvm-projects clang --llvm-projects lld 
      ```
 </details>
@@ -1,39 +0,0 @@
 //! The revive LLVM build type.
 /// The revive LLVM build type.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum BuildType {
    /// The debug build.
    Debug,
    /// The release build.
    Release,
    /// The release with debug info build.
    RelWithDebInfo,
    /// The minimal size release build.
    MinSizeRel,
 }
 impl std::str::FromStr for BuildType {
    type Err = String;
    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value {
            "Debug" => Ok(Self::Debug),
            "Release" => Ok(Self::Release),
            "RelWithDebInfo" => Ok(Self::RelWithDebInfo),
            "MinSizeRel" => Ok(Self::MinSizeRel),
            value => Err(format!("Unsupported build type: `{}`", value)),
        }
    }
 }
 impl std::fmt::Display for BuildType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Debug => write!(f, "Debug"),
            Self::Release => write!(f, "Release"),
            Self::RelWithDebInfo => write!(f, "RelWithDebInfo"),
            Self::MinSizeRel => write!(f, "MinSizeRel"),
        }
    }
 }
@@ -1,137 +0,0 @@
 //! Utilities for compiling the LLVM compiler-rt builtins.
 /// Static CFLAGS variable passed to the compiler building the compiler-rt builtins.
 const C_FLAGS: [&str; 6] = [
    "--target=riscv64",
    "-march=rv64emac",
    "-mabi=lp64e",
    "-mcpu=generic-rv64",
    "-nostdlib",
    "-nodefaultlibs",
 ];
 /// Static CMAKE arguments for building the compiler-rt builtins.
 const CMAKE_STATIC_ARGS: [&str; 14] = [
    "-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'",
    "-DCOMPILER_RT_DEFAULT_TARGET_ONLY='On'",
    "-DCOMPILER_RT_BAREMETAL_BUILD='On'",
    "-DCMAKE_BUILD_WITH_INSTALL_RPATH=1",
    "-DCMAKE_EXPORT_COMPILE_COMMANDS='On'",
    "-DCMAKE_SYSTEM_NAME='unknown'",
    "-DCMAKE_C_COMPILER_TARGET='riscv64'",
    "-DCMAKE_ASM_COMPILER_TARGET='riscv64'",
    "-DCMAKE_CXX_COMPILER_TARGET='riscv64'",
 ];
 /// Dynamic cmake arguments for building the compiler-rt builtins.
 fn cmake_dynamic_args(
    build_type: crate::BuildType,
    target_env: crate::target_env::TargetEnv,
 ) -> anyhow::Result<[String; 13]> {
    let llvm_compiler_rt_target = crate::LLVMPath::llvm_target_compiler_rt()?;
    // The Emscripten target needs to use the host LLVM tools.
    let llvm_target_host = if target_env == crate::target_env::TargetEnv::Emscripten {
        crate::LLVMPath::llvm_build_host()?
    } else {
        crate::LLVMPath::llvm_target_final()?
    };
    let mut clang_path = llvm_target_host.to_path_buf();
    clang_path.push("bin/clang");
    let mut clangxx_path = llvm_target_host.to_path_buf();
    clangxx_path.push("bin/clang++");
    let mut llvm_config_path = llvm_target_host.to_path_buf();
    llvm_config_path.push("bin/llvm-config");
    let mut ar_path = llvm_target_host.to_path_buf();
    ar_path.push("bin/llvm-ar");
    let mut nm_path = llvm_target_host.to_path_buf();
    nm_path.push("bin/llvm-nm");
    let mut ranlib_path = llvm_target_host.to_path_buf();
    ranlib_path.push("bin/llvm-ranlib");
    let mut linker_path = llvm_target_host.to_path_buf();
    linker_path.push("bin/ld.lld");
    Ok([
        format!(
            "-DCMAKE_INSTALL_PREFIX='{}'",
            llvm_compiler_rt_target.to_string_lossy().as_ref(),
        ),
        format!("-DCMAKE_BUILD_TYPE='{build_type}'"),
        format!(
            "-DCOMPILER_RT_TEST_COMPILER='{}'",
            clang_path.to_string_lossy()
        ),
        format!("-DCMAKE_C_FLAGS='{}'", C_FLAGS.join(" ")),
        format!("-DCMAKE_ASM_FLAGS='{}'", C_FLAGS.join(" ")),
        format!("-DCMAKE_CXX_FLAGS='{}'", C_FLAGS.join(" ")),
        format!("-DCMAKE_C_COMPILER='{}'", clang_path.to_string_lossy()),
        format!("-DCMAKE_ASM_COMPILER='{}'", clang_path.to_string_lossy()),
        format!("-DCMAKE_CXX_COMPILER='{}'", clangxx_path.to_string_lossy()),
        format!("-DCMAKE_AR='{}'", ar_path.to_string_lossy()),
        format!("-DCMAKE_NM='{}'", nm_path.to_string_lossy()),
        format!("-DCMAKE_RANLIB='{}'", ranlib_path.to_string_lossy()),
        format!(
            "-DLLVM_CONFIG_PATH='{}'",
            llvm_config_path.to_string_lossy()
        ),
    ])
 }
 /// Build the compiler-rt builtins library.
 pub fn build(
    build_type: crate::BuildType,
    target_env: crate::target_env::TargetEnv,
    default_target: Option<crate::TargetTriple>,
    extra_args: &[String],
    ccache_variant: Option<crate::ccache_variant::CcacheVariant>,
    sanitizer: Option<crate::sanitizer::Sanitizer>,
 ) -> anyhow::Result<()> {
    log::info!("building compiler-rt for rv64emac");
    crate::utils::check_presence("cmake")?;
    crate::utils::check_presence("ninja")?;
    let llvm_module_compiler_rt = crate::LLVMPath::llvm_module_compiler_rt()?;
    let llvm_compiler_rt_build = crate::LLVMPath::llvm_build_compiler_rt()?;
    crate::utils::command(
        std::process::Command::new("cmake")
            .args([
                "-S",
                llvm_module_compiler_rt.to_string_lossy().as_ref(),
                "-B",
                llvm_compiler_rt_build.to_string_lossy().as_ref(),
                "-G",
                "Ninja",
            ])
            .args(CMAKE_STATIC_ARGS)
            .args(cmake_dynamic_args(build_type, target_env)?)
            .args(extra_args)
            .args(crate::platforms::shared::shared_build_opts_ccache(
                ccache_variant,
            ))
            .args(crate::platforms::shared::shared_build_opts_default_target(
                default_target,
            ))
            .args(crate::platforms::shared::shared_build_opts_sanitizers(
                sanitizer,
            )),
        "LLVM compiler-rt building cmake",
    )?;
    crate::utils::ninja(&llvm_compiler_rt_build)?;
    Ok(())
 }
@@ -1,31 +0,0 @@
 //! Compiler cache variants.
 /// The list compiler cache variants to be used as constants.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum CcacheVariant {
    /// Standard ccache.
    Ccache,
    /// Mozilla's sccache.
    Sccache,
 }
 impl std::str::FromStr for CcacheVariant {
    type Err = String;
    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value {
            "ccache" => Ok(Self::Ccache),
            "sccache" => Ok(Self::Sccache),
            value => Err(format!("Unsupported ccache variant: `{}`", value)),
        }
    }
 }
 impl std::fmt::Display for CcacheVariant {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Self::Ccache => write!(f, "ccache"),
            Self::Sccache => write!(f, "sccache"),
        }
    }
 }
@@ -1,340 +0,0 @@
 //! The revive LLVM builder library.
 pub mod build_type;
 pub mod builtins;
 pub mod ccache_variant;
 pub mod llvm_path;
 pub mod llvm_project;
 pub mod lock;
 pub mod platforms;
 pub mod sanitizer;
 pub mod target_env;
 pub mod target_triple;
 pub mod utils;
 pub use self::build_type::BuildType;
 pub use self::llvm_path::LLVMPath;
 pub use self::lock::Lock;
 pub use self::platforms::Platform;
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 pub use target_env::TargetEnv;
 pub use target_triple::TargetTriple;
 /// Executes the LLVM repository cloning.
 pub fn clone(lock: Lock, deep: bool, target_env: TargetEnv) -> anyhow::Result<()> {
    utils::check_presence("git")?;
    if target_env == TargetEnv::Emscripten {
        utils::install_emsdk()?;
    }
    let destination_path = PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE);
    if destination_path.exists() {
        log::warn!(
            "LLVM repository directory {} already exists, falling back to checkout",
            destination_path.display()
        );
        return checkout(lock, false);
    }
    let mut clone_args = vec!["clone", "--branch", lock.branch.as_str()];
    if !deep {
        clone_args.push("--depth");
        clone_args.push("1");
    }
    utils::command(
        Command::new("git")
            .args(clone_args)
            .arg(lock.url.as_str())
            .arg(destination_path.to_string_lossy().as_ref()),
        "LLVM repository cloning",
    )?;
    if let Some(r#ref) = lock.r#ref {
        utils::command(
            Command::new("git")
                .args(["checkout", r#ref.as_str()])
                .current_dir(destination_path.to_string_lossy().as_ref()),
            "LLVM repository commit checking out",
        )?;
    }
    Ok(())
 }
 /// Executes the checkout of the specified branch.
 pub fn checkout(lock: Lock, force: bool) -> anyhow::Result<()> {
    let destination_path = PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE);
    utils::command(
        Command::new("git")
            .current_dir(destination_path.as_path())
            .args(["fetch", "--all", "--tags"]),
        "LLVM repository data fetching",
    )?;
    if force {
        utils::command(
            Command::new("git")
                .current_dir(destination_path.as_path())
                .args(["clean", "-d", "-x", "--force"]),
            "LLVM repository cleaning",
        )?;
    }
    utils::command(
        Command::new("git")
            .current_dir(destination_path.as_path())
            .args(["checkout", "--force", lock.branch.as_str()]),
        "LLVM repository data pulling",
    )?;
    if let Some(r#ref) = lock.r#ref {
        let mut checkout_command = Command::new("git");
        checkout_command.current_dir(destination_path.as_path());
        checkout_command.arg("checkout");
        if force {
            checkout_command.arg("--force");
        }
        checkout_command.arg(r#ref);
        utils::command(&mut checkout_command, "LLVM repository checking out")?;
    }
    Ok(())
 }
 /// Executes the building of the LLVM framework for the platform determined by the cfg macro.
 /// Since cfg is evaluated at compile time, overriding the platform with a command-line
 /// argument is not possible. So for cross-platform testing, comment out all but the
 /// line to be tested, and perhaps also checks in the platform-specific build method.
 #[allow(clippy::too_many_arguments)]
 pub fn build(
    build_type: BuildType,
    target_env: TargetEnv,
    targets: HashSet<Platform>,
    llvm_projects: HashSet<llvm_project::LLVMProject>,
    enable_rtti: bool,
    default_target: Option<TargetTriple>,
    enable_tests: bool,
    enable_coverage: bool,
    extra_args: &[String],
    ccache_variant: Option<ccache_variant::CcacheVariant>,
    enable_assertions: bool,
    sanitizer: Option<sanitizer::Sanitizer>,
    enable_valgrind: bool,
 ) -> anyhow::Result<()> {
    log::trace!("build type: {:?}", build_type);
    log::trace!("target env: {:?}", target_env);
    log::trace!("targets: {:?}", targets);
    log::trace!("llvm projects: {:?}", llvm_projects);
    log::trace!("enable rtti: {:?}", enable_rtti);
    log::trace!("default target: {:?}", default_target);
    log::trace!("eneable tests: {:?}", enable_tests);
    log::trace!("enable_coverage: {:?}", enable_coverage);
    log::trace!("extra args: {:?}", extra_args);
    log::trace!("sanitzer: {:?}", sanitizer);
    log::trace!("enable valgrind: {:?}", enable_valgrind);
    if !PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE).exists() {
        log::error!(
            "LLVM project source directory {} does not exist (run `revive-llvm --target-env {} clone`)",
            LLVMPath::DIRECTORY_LLVM_SOURCE,
            target_env
        )
    }
    std::fs::create_dir_all(llvm_path::DIRECTORY_LLVM_TARGET.get().unwrap())?;
    if cfg!(target_arch = "x86_64") {
        if cfg!(target_os = "linux") {
            if target_env == TargetEnv::MUSL {
                platforms::x86_64_linux_musl::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                    enable_valgrind,
                )?;
            } else if target_env == TargetEnv::GNU {
                platforms::x86_64_linux_gnu::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                    enable_valgrind,
                )?;
            } else if target_env == TargetEnv::Emscripten {
                platforms::wasm32_emscripten::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                    enable_valgrind,
                )?;
            } else {
                anyhow::bail!("Unsupported target environment for x86_64 and Linux");
            }
        } else if cfg!(target_os = "macos") {
            platforms::x86_64_macos::build(
                build_type,
                targets,
                llvm_projects,
                enable_rtti,
                default_target,
                enable_tests,
                enable_coverage,
                extra_args,
                ccache_variant,
                enable_assertions,
                sanitizer,
            )?;
        } else if cfg!(target_os = "windows") {
            platforms::x86_64_windows_gnu::build(
                build_type,
                targets,
                llvm_projects,
                enable_rtti,
                default_target,
                enable_tests,
                enable_coverage,
                extra_args,
                ccache_variant,
                enable_assertions,
                sanitizer,
            )?;
        } else {
            anyhow::bail!("Unsupported target OS for x86_64");
        }
    } else if cfg!(target_arch = "aarch64") {
        if cfg!(target_os = "linux") {
            if target_env == TargetEnv::MUSL {
                platforms::aarch64_linux_musl::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                    enable_valgrind,
                )?;
            } else if target_env == TargetEnv::GNU {
                platforms::aarch64_linux_gnu::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                    enable_valgrind,
                )?;
            } else {
                anyhow::bail!("Unsupported target environment for aarch64 and Linux");
            }
        } else if cfg!(target_os = "macos") {
            if target_env == TargetEnv::Emscripten {
                platforms::wasm32_emscripten::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                    enable_valgrind,
                )?;
            } else {
                platforms::aarch64_macos::build(
                    build_type,
                    targets,
                    llvm_projects,
                    enable_rtti,
                    default_target,
                    enable_tests,
                    enable_coverage,
                    extra_args,
                    ccache_variant,
                    enable_assertions,
                    sanitizer,
                )?;
            }
        } else {
            anyhow::bail!("Unsupported target OS for aarch64");
        }
    } else {
        anyhow::bail!("Unsupported target architecture");
    }
    crate::builtins::build(
        build_type,
        target_env,
        default_target,
        extra_args,
        ccache_variant,
        sanitizer,
    )?;
    Ok(())
 }
 /// Executes the build artifacts cleaning.
 pub fn clean() -> anyhow::Result<()> {
    let remove_if_exists = |path: &Path| {
        if !path.exists() {
            return Ok(());
        }
        log::info!("deleting {}", path.display());
        std::fs::remove_dir_all(path)
    };
    remove_if_exists(
        llvm_path::DIRECTORY_LLVM_TARGET
            .get()
            .expect("target_env is always set because of the default value")
            .parent()
            .expect("target_env parent directory is target-llvm"),
    )?;
    remove_if_exists(&PathBuf::from(LLVMPath::DIRECTORY_EMSDK_SOURCE))?;
    remove_if_exists(&PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE))?;
    remove_if_exists(&PathBuf::from(LLVMPath::DIRECTORY_LLVM_HOST_SOURCE))?;
    Ok(())
 }
@@ -1,151 +0,0 @@
 //! The revive LLVM builder constants.
 use std::path::PathBuf;
 use std::sync::OnceLock;
 pub static DIRECTORY_LLVM_TARGET: OnceLock<PathBuf> = OnceLock::new();
 /// The LLVM path resolver.
 pub struct LLVMPath {}
 impl LLVMPath {
    /// The LLVM source directory.
    pub const DIRECTORY_LLVM_SOURCE: &'static str = "./llvm/";
    /// The LLVM host source directory for stage 1 of multistage MUSL and Emscripten builds.
    ///
    /// We use upstream LLVM anyways; re-use the same tree for host and target builds.
    pub const DIRECTORY_LLVM_HOST_SOURCE: &'static str = Self::DIRECTORY_LLVM_SOURCE;
    /// The Emscripten SDK source directory.
    pub const DIRECTORY_EMSDK_SOURCE: &'static str = "./emsdk/";
    /// Returns the path to the `llvm` stage 1 host LLVM source module directory.
    pub fn llvm_host_module_llvm() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(Self::DIRECTORY_LLVM_HOST_SOURCE);
        path.push("llvm");
        crate::utils::absolute_path(path).inspect(|absolute_path| {
            log::debug!(
                "llvm stage 1 host llvm source module: {}",
                absolute_path.display()
            )
        })
    }
    /// Returns the path to the `llvm` LLVM source module directory.
    pub fn llvm_module_llvm() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(Self::DIRECTORY_LLVM_SOURCE);
        path.push("llvm");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm source module: {}", absolute_path.display()))
    }
    /// Returns the path to the MUSL source.
    pub fn musl_source(name: &str) -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push(name);
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("musl source: {}", absolute_path.display()))
    }
    /// Returns the path to the MUSL build directory.
    pub fn musl_build(source_directory: &str) -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push(source_directory);
        path.push("build");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("musl build: '{}'", absolute_path.display()))
    }
    /// Returns the path to the LLVM CRT build directory.
    pub fn llvm_build_crt() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("build-crt");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm build crt: {}", absolute_path.display()))
    }
    /// Returns the path to the LLVM host build directory.
    pub fn llvm_build_host() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("build-host");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm build host: {}", absolute_path.display()))
    }
    /// Returns the path to the LLVM final build directory.
    pub fn llvm_build_final() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("build-final");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm build final: {}", absolute_path.display()))
    }
    /// Returns the path to the MUSL target directory.
    pub fn musl_target() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("target-musl");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("musl target: {}", absolute_path.display()))
    }
    /// Returns the path to the LLVM CRT target directory.
    pub fn llvm_target_crt() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("target-crt");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm crt target: {}", absolute_path.display()))
    }
    /// Returns the path to the LLVM host target directory.
    pub fn llvm_target_host() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("target-host");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm host target: {}", absolute_path.display()))
    }
    /// Returns the path to the LLVM final target directory.
    pub fn llvm_target_final() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("target-final");
        crate::utils::absolute_path(path)
            .inspect(|absolute_path| log::debug!("llvm final target: {}", absolute_path.display()))
    }
    /// Returns the path to the LLVM compiler builtin target directory.
    pub fn llvm_module_compiler_rt() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(Self::DIRECTORY_LLVM_SOURCE);
        path.push("compiler-rt");
        crate::utils::absolute_path(path).inspect(|absolute_path| {
            log::debug!("compiler-rt source dir: {}", absolute_path.display())
        })
    }
    /// Returns the path to the LLVM compiler-rt target directory.
    pub fn llvm_target_compiler_rt() -> anyhow::Result<PathBuf> {
        Self::llvm_target_final()
    }
    /// Returns the path to the LLVM compiler-rt build directory.
    pub fn llvm_build_compiler_rt() -> anyhow::Result<PathBuf> {
        let mut path = PathBuf::from(DIRECTORY_LLVM_TARGET.get().unwrap());
        path.push("build-compiler-rt");
        crate::utils::absolute_path(path).inspect(|absolute_path| {
            log::debug!("llvm compiler-rt build: {}", absolute_path.display())
        })
    }
    /// Returns the path to the LLVM target final bin path.
    ///
    pub fn llvm_target_final_bin(
        target_env: crate::target_env::TargetEnv,
    ) -> anyhow::Result<PathBuf> {
        let mut path = Self::llvm_target_final()?;
        path.push("bin");
        path.push(format!("{target_env}"));
        crate::utils::absolute_path(path).inspect(|absolute_path| {
            log::debug!("llvm target final bin: {}", absolute_path.display())
        })
    }
 }
@@ -1,39 +0,0 @@
 //! The LLVM projects to enable during the build.
 /// The list of LLVM projects used as constants.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum LLVMProject {
    /// The Clang compiler.
    CLANG,
    /// LLD, the LLVM linker.
    LLD,
    /// The LLVM debugger.
    LLDB,
    /// The MLIR compiler.
    MLIR,
 }
 impl std::str::FromStr for LLVMProject {
    type Err = String;
    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value.to_lowercase().as_str() {
            "clang" => Ok(Self::CLANG),
            "lld" => Ok(Self::LLD),
            "lldb" => Ok(Self::LLDB),
            "mlir" => Ok(Self::MLIR),
            value => Err(format!("Unsupported LLVM project to enable: `{}`", value)),
        }
    }
 }
 impl std::fmt::Display for LLVMProject {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Self::CLANG => write!(f, "clang"),
            Self::LLD => write!(f, "lld"),
            Self::LLDB => write!(f, "lldb"),
            Self::MLIR => write!(f, "mlir"),
        }
    }
 }
@@ -1,37 +0,0 @@
 //! The revive LLVM builder lock file.
 use anyhow::Context;
 use std::fs::File;
 use std::io::Read;
 use std::path::PathBuf;
 use serde::Deserialize;
 use serde::Serialize;
 /// The default lock file location.
 pub const LLVM_LOCK_DEFAULT_PATH: &str = "LLVM.lock";
 /// The lock file data.
 ///
 /// This file describes the exact reference of the LLVM framework.
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Lock {
    /// The LLVM repository URL.
    pub url: String,
    /// The LLVM repository branch.
    pub branch: String,
    /// The LLVM repository commit reference.
    pub r#ref: Option<String>,
 }
 impl TryFrom<&PathBuf> for Lock {
    type Error = anyhow::Error;
    fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
        let mut config_str = String::new();
        let mut config_file =
            File::open(path).with_context(|| format!("Error opening {:?} file", path))?;
        config_file.read_to_string(&mut config_str)?;
        Ok(toml::from_str(&config_str)?)
    }
 }
--- a/Show More
+++ b/Show More
		`@@ -1 +0,0 @@`
			`https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/SECURITY.md`
		`@@ -1 +0,0 @@`
			`include!(concat!(env!("OUT_DIR"), "/compiler_rt.rs"));`