init

.cargo/config.toml

@@ -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/emscripten/embed/soljson_interface.js",
-    "-Clink-arg=--pre-js=js/emscripten/embed/pre.js",
-    "-Clink-arg=-sSTACK_SIZE=128kb",
-    "-Clink-arg=-sNODEJS_CATCH_EXIT=0"
-]

.dockerignore

@@ -1,7 +0,0 @@
-emsdk
-llvm*/
-target-llvm/
-target/
-node_modules/
-utils/
-build/

.github/actions/get-emsdk/action.yml

@@ -1,19 +0,0 @@
-name: "Get Emscripten SDK"
-inputs:
-  version:
-    description: ""
-    required: false
-    default: "4.0.9"
-
-
-runs:
-  using: "composite"
-  steps:
-    - name: install emsdk
-      shell: bash
-      run: |
-        git clone https://github.com/emscripten-core/emsdk.git ./emsdk/
-        cd emsdk
-        git checkout tags/${{ inputs.version }}
-        ./emsdk install ${{ inputs.version }}
-        ./emsdk activate ${{ inputs.version }}

.github/actions/get-llvm/action.yml

@@ -1,70 +0,0 @@
-# example:
-#       - uses: ./.github/actions/get-llvm
-#         with:
-#           target: x86_64-unknown-linux-gnu
-
-name: "Download LLVM"
-inputs:
-  target:
-    required: true
-
-runs:
-  using: "composite"
-  steps:
-    - name: find asset
-      id: find
-      uses: actions/github-script@v7
-      env:
-        target: ${{ inputs.target }}
-      with:
-        result-encoding: string
-        script: |
-          let page = 1;
-          let releases = [];
-
-          let releasePrefix = "llvm-"
-          let target = process.env.target
-
-          do {
-            const res = await github.rest.repos.listReleases({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              per_page: 50,
-              page,
-            });
-
-            releases = res.data
-            releases.sort((a, b) => {
-              return (a.published_at < b.published_at) ? 1 : ((a.published_at > b.published_at) ? -1 : 0);
-            });
-
-            let llvmLatestRelease = releases.find(release => {
-              return release.tag_name.startsWith(releasePrefix);
-            });
-            if (llvmLatestRelease){
-                let asset = llvmLatestRelease.assets.find(asset =>{
-                    return asset.name.includes(target);
-                });
-                if (!asset){
-                  core.setFailed(`Artifact for '${target}' not found in release ${llvmLatestRelease.tag_name} (${llvmLatestRelease.html_url})`);
-                  process.exit();
-                }
-                return asset.browser_download_url;
-            }
-
-            page++;
-          } while(releases.length > 0);
-
-          core.setFailed(`No LLVM releases with '${releasePrefix}' atifacts found! Please release LLVM before running this workflow.`);
-          process.exit();
-
-    - name: download
-      shell: bash
-      run: |
-        curl -sSLo llvm.tar.gz ${{ steps.find.outputs.result }}
-
-    - name: unpack
-      shell: bash
-      run: |
-        tar -xf llvm.tar.gz
-        rm llvm.tar.gz

.github/actions/get-solc/action.yml

@@ -1,36 +0,0 @@
-name: "Install Solidity Compiler"
-description: "Installs the Ethereum solc Solidity compiler frontend executable"
-
-runs:
-  using: "composite"
-  steps:
-    - name: Figure out Solc Download URL
-      shell: bash
-      run: |
-        if [[ "${{ runner.os }}" == "Linux" ]]; then
-          echo "SOLC_NAME=solc-static-linux" >> $GITHUB_ENV
-        elif [[ "${{ runner.os }}" == "Windows" ]]; then
-          echo "SOLC_NAME=solc-windows.exe" >> $GITHUB_ENV
-        else
-          echo "SOLC_NAME=solc-macos" >> $GITHUB_ENV
-        fi
-
-    - name: Download Solc
-      shell: bash
-      run: |
-        mkdir -p solc
-        curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.30/${SOLC_NAME}
-
-    - name: Make Solc Executable
-      if: ${{ runner.os == 'Windows' }}
-      shell: bash
-      run: |
-        echo "$(pwd -W)\\solc" >> $GITHUB_PATH
-        mv solc/solc solc/solc.exe
-
-    - name: Make Solc Executable
-      if: ${{ runner.os != 'Windows' }}
-      shell: bash
-      run: |
-        echo "$(pwd)/solc" >> $GITHUB_PATH
-        chmod +x solc/solc

.github/scripts/json_generator.py

@@ -1,175 +0,0 @@
-#!/usr/bin/env python3
-"""
-This script generates JSON files for different platforms based on GitHub release data.
-It fetches release information from a specified GitHub repository and tag,
-parses the release assets, and generates JSON files for each platform with relevant metadata.
-It also handles checksum files and updates a list.json file for each platform.
-It requires the GITHUB_TOKEN environment variable to be set for authentication.
-Usage:
-    python json_generator.py <repo> <tag>
-"""
-import os
-import sys
-import json
-import requests
-
-def validate_github_token():
-    """Validate that GITHUB_TOKEN environment variable is set."""
-    if 'GITHUB_TOKEN' not in os.environ:
-        print("Error: GITHUB_TOKEN environment variable is not set.")
-        sys.exit(1)
-
-def fetch_release_data(repo, tag):
-    """Fetch release data from GitHub API."""
-    url = f"https://api.github.com/repos/{repo}/releases/tags/{tag}"
-    headers = {
-        'Authorization': f"Bearer {os.environ['GITHUB_TOKEN']}",
-        'Accept': 'application/vnd.github+json',
-        'X-GitHub-Api-Version': '2022-11-28'
-    }
-
-    try:
-        response = requests.get(url, headers=headers)
-        response.raise_for_status()
-        return response.json()
-    except requests.RequestException as e:
-        print(f"Error fetching release data: {e}")
-        sys.exit(1)
-
-def fetch_checksum_file(release_data):
-    """
-    Fetch the checksum.txt file from the release assets
-    and parse it into a dictionary mapping file names to their SHA256 checksums.
-    """
-    checksums = {}
-
-    # Find the checksum.txt asset URL
-    checksum_asset = None
-    for asset in release_data['assets']:
-        if asset['name'] == 'checksums.txt':
-            checksum_asset = asset
-            break
-
-    if not checksum_asset:
-        print("Warning: checksum.txt file not found in release assets.")
-        return checksums
-
-    # Download the checksum file
-    headers = {
-        'Authorization': f"Bearer {os.environ['GITHUB_TOKEN']}",
-        'Accept': 'application/octet-stream'
-    }
-
-    try:
-        response = requests.get(checksum_asset['browser_download_url'], headers=headers)
-        response.raise_for_status()
-
-        # Parse checksum file
-        for line in response.text.splitlines():
-            if line.strip():
-                checksum, filename = line.strip().split(None, 1)
-                checksums[filename] = checksum
-
-        return checksums
-    except requests.RequestException as e:
-        print(f"Error fetching checksum file: {e}")
-        return checksums
-    except Exception as e:
-        print(f"Error parsing checksum file: {e}")
-        return checksums
-
-def extract_build_hash(target_commitish):
-    """Extract the first 8 characters of the commit hash."""
-    return f"commit.{target_commitish[:8]}"
-
-def generate_asset_json(release_data, asset, checksums):
-    """Generate JSON for a specific asset."""
-    version = release_data['tag_name'].lstrip('v')
-    build = extract_build_hash(release_data['target_commitish'])
-    long_version = f"{version}+{build}"
-
-    # Get SHA256 checksum if available
-    sha256 = checksums.get(asset['name'], "")
-
-    return {
-        "name": asset['name'],
-        "version": version,
-        "build": build,
-        "longVersion": long_version,
-        "url": asset['browser_download_url'],
-        "sha256": sha256,
-        "firstSolcVersion": os.environ.get("FIRST_SOLC_VERSION", ""),
-        "lastSolcVersion": os.environ.get("LAST_SOLC_VERSION", "")
-    }
-
-def save_platform_json(platform_folder, asset_json, tag):
-    """Save asset JSON and update list.json for a specific platform."""
-    # Create platform folder if it doesn't exist
-    os.makedirs(platform_folder, exist_ok=True)
-
-    # Update or create list.json
-    list_file_path = os.path.join(platform_folder, "list.json")
-
-    if os.path.exists(list_file_path):
-        with open(list_file_path, 'r') as f:
-            try:
-                list_data = json.load(f)
-            except json.JSONDecodeError:
-                list_data = {"builds": [], "releases": {}, "latestRelease": ""}
-    else:
-        list_data = {"builds": [], "releases": {}, "latestRelease": ""}
-
-    # Remove any existing entry with the same path
-    list_data['builds'] = [
-        build for build in list_data['builds']
-        if build['version'] != asset_json['version']
-    ]
-    # Add the new build
-    list_data['builds'].append(asset_json)
-
-    # Update releases
-    version = asset_json['version']
-    list_data['releases'][version] = f"{asset_json['name']}+{asset_json['longVersion']}"
-
-    # Update latest release
-    list_data['latestRelease'] = version
-
-    with open(list_file_path, 'w') as f:
-        json.dump(list_data, f, indent=4)
-
-def main():
-    # Validate arguments
-    if len(sys.argv) != 3:
-        print("Usage: python script.py <repo> <tag>")
-        sys.exit(1)
-
-    repo, tag = sys.argv[1], sys.argv[2]
-
-    # Validate GitHub token
-    validate_github_token()
-
-    # Fetch release data
-    release_data = fetch_release_data(repo, tag)
-
-    # Fetch checksums
-    checksums = fetch_checksum_file(release_data)
-
-    # Mapping of asset names to platform folders
-    platform_mapping = {
-        'resolc-x86_64-unknown-linux-musl': 'linux',
-        'resolc-universal-apple-darwin': 'macos',
-        'resolc-x86_64-pc-windows-msvc.exe': 'windows',
-        'resolc_web.js': 'wasm'
-    }
-
-    # Process each asset
-    for asset in release_data['assets']:
-        platform_name = platform_mapping.get(asset['name'])
-        if platform_name:
-            platform_folder = os.path.join(platform_name)
-            asset_json = generate_asset_json(release_data, asset, checksums)
-            save_platform_json(platform_folder, asset_json, tag)
-            print(f"Processed {asset['name']} for {platform_name}")
-
-if __name__ == "__main__":
-    main()

.github/scripts/json_generator_nightly.py

@@ -1,155 +0,0 @@
-#!/usr/bin/env python3
-"""
-This script generates JSON files for different platforms based on GitHub data.
-Requires the GITHUB_SHA, FIRST_SOLC_VERSION, LAST_SOLC_VERSION, TAG and FILEPATH environment variables to be set.
-Usage:
-    python json_generator_nightly.py
-"""
-import os
-import sys
-import json
-from datetime import datetime
-
-def validate_env_variables():
-    """Validate that environment variables are set."""
-    if "GITHUB_SHA" not in os.environ:
-        print("Error: GITHUB_SHA environment variable is not set.")
-        sys.exit(1)
-    if "FIRST_SOLC_VERSION" not in os.environ:
-        print("Error: FIRST_SOLC_VERSION environment variable is not set.")
-        sys.exit(1)
-    if "LAST_SOLC_VERSION" not in os.environ:
-        print("Error: LAST_SOLC_VERSION environment variable is not set.")
-        sys.exit(1)
-    if "TAG" not in os.environ:
-        print("Error: TAG environment variable is not set.")
-        sys.exit(1)
-    if "FILEPATH" not in os.environ:
-        print("Error: FILEPATH environment variable is not set.")
-        sys.exit(1)
-
-
-def fetch_data_file():
-    """
-    Fetch the data.json file with artifacts urls and sha256 checksums
-    and parse it into a single dictionary mapping artifact names to their URLs and SHAs.
-    """
-    # read data.json file
-    artifacts_data = {}
-    data_file_path = os.environ["FILEPATH"]
-    if not os.path.exists(data_file_path):
-        print("Error: data.json file not found.")
-        sys.exit(1)
-    with open(data_file_path, 'r') as f:
-        try:
-            artifacts_data = json.load(f)
-        except json.JSONDecodeError:
-            print("Error: data.json file is not a valid JSON.")
-            sys.exit(1)
-
-    result = {}
-
-    for item in artifacts_data:
-        for key, value in item.items():
-            if key.endswith('_url'):
-                base_key = key.rsplit('_url', 1)[0]
-                if base_key not in result:
-                    result[base_key] = {}
-                result[base_key]['url'] = value
-            elif key.endswith('_sha'):
-                base_key = key.rsplit('_sha', 1)[0]
-                if base_key not in result:
-                    result[base_key] = {}
-                result[base_key]['sha'] = value
-
-    return result
-
-
-
-
-
-def extract_build_hash():
-    """Extract the first 8 characters of the commit hash."""
-    sha = os.environ.get("GITHUB_SHA")
-    return f"commit.{sha[:8]}"
-
-def generate_asset_json_nightly(name, url, checksum):
-    """Generate JSON for a specific asset."""
-    # Date in format YYYY-MM-DD
-    date = datetime.now().strftime("%Y.%-m.%-d")
-    last_version = os.environ.get("TAG").replace('v','')
-    version = f"{last_version}-nightly.{date}"
-    SHA = os.environ.get("GITHUB_SHA", "")[:8]
-    build = f"commit.{SHA}"
-    long_version = f"{version}+{build}"
-
-    return {
-        "name": name,
-        "version": version,
-        "build": build,
-        "longVersion": long_version,
-        "url": url,
-        "sha256": checksum,
-        "firstSolcVersion": os.environ.get("FIRST_SOLC_VERSION"),
-        "lastSolcVersion": os.environ.get("LAST_SOLC_VERSION")
-    }
-
-def save_platform_json(platform_folder, asset_json):
-    """Save asset JSON and update list.json for a specific platform."""
-    # Create platform folder if it doesn't exist
-    os.makedirs(platform_folder, exist_ok=True)
-
-    # Update or create list.json
-    list_file_path = os.path.join(platform_folder, "list.json")
-
-    if os.path.exists(list_file_path):
-        with open(list_file_path, 'r') as f:
-            try:
-                list_data = json.load(f)
-            except json.JSONDecodeError:
-                list_data = {"builds": [], "releases": {}, "latestRelease": ""}
-    else:
-        list_data = {"builds": [], "releases": {}, "latestRelease": ""}
-
-    # Remove any existing entry with the same path
-    list_data['builds'] = [
-        build for build in list_data['builds']
-        if build['version'] != asset_json['version']
-    ]
-    # Add the new build
-    list_data['builds'].append(asset_json)
-
-    # Update releases
-    version = asset_json['version']
-    list_data['releases'][version] = f"{asset_json['name']}+{asset_json['longVersion']}"
-
-    # Update latest release
-    list_data['latestRelease'] = version
-
-    with open(list_file_path, 'w') as f:
-        json.dump(list_data, f, indent=4)
-
-def main():
-
-    validate_env_variables()
-    data = fetch_data_file()
-
-    # Mapping of asset names to platform folders
-    platform_mapping = {
-        'resolc-x86_64-unknown-linux-musl': 'linux',
-        'resolc-universal-apple-darwin': 'macos',
-        'resolc-x86_64-pc-windows-msvc': 'windows',
-        'resolc-web.js': 'wasm'
-    }
-
-    # Process each asset
-    for asset in data.keys():
-        platform_name = platform_mapping.get(asset)
-        if platform_name:
-            platform_folder = os.path.join(platform_name)
-            asset_json = generate_asset_json_nightly(asset, data[asset]['url'], data[asset]['sha'])
-            save_platform_json(platform_folder, asset_json)
-            print(f"Processed {asset} for {platform_name}")
-
-if __name__ == "__main__":
-    main()

.github/workflows/generate_versions.yml

@@ -1,64 +0,0 @@
-name: Generate JSON for resolc-bin
-on:
-  release:
-    types: [published]
-
-jobs:
-  generateJson:
-    runs-on: ubuntu-latest
-    if: contains(github.event.release.tag_name, 'llvm') == false
-    environment: tags
-    env:
-      # the token is needed for json_generator.py
-      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          path: tmp
-
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          repository: paritytech/resolc-bin
-          path: resolc-bin
-
-      - uses: actions/create-github-app-token@v1
-        id: app-token
-        with:
-          app-id: ${{ secrets.REVIVE_JSON_APP_ID }}
-          private-key: ${{ secrets.REVIVE_JSON_APP_KEY }}
-          owner: paritytech
-          repositories: resolc-bin
-
-      - name: Generate json and push
-        env:
-          TOKEN: ${{ steps.app-token.outputs.token }}
-          APP_NAME: "paritytech-revive-json"
-          Green: "\e[32m"
-          NC: "\e[0m"
-        run: |
-          sudo apt-get update && sudo apt-get install -y wget
-          wget https://github.com/${GITHUB_REPOSITORY}/releases/download/${GITHUB_REF_NAME}/resolc-x86_64-unknown-linux-musl
-          chmod +x resolc-x86_64-unknown-linux-musl
-          export FIRST_SOLC_VERSION=$(./resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 1 -d "," | tr -d ">=")
-          export LAST_SOLC_VERSION=$(./resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 2 -d "," | tr -d "<=")
-
-          cd resolc-bin
-          python ../tmp/.github/scripts/json_generator.py ${GITHUB_REPOSITORY} ${{ github.event.release.tag_name }}
-
-          echo "${Green}Add new remote with gh app token${NC}"
-          git remote set-url origin $(git config remote.origin.url | sed "s/github.com/${APP_NAME}:${TOKEN}@github.com/g")
-
-          echo "${Green}Remove http section that causes issues with gh app auth token${NC}"
-          sed -i.bak '/\[http/d' ./.git/config
-          sed -i.bak '/extraheader/d' ./.git/config
-
-          git config user.email "ci@parity.io"
-          git config user.name "${APP_NAME}"
-
-          git add .
-          git commit -m "Update json"
-          git push origin main
-
-          echo "::notice::info.list files were successfully published to https://github.com/paritytech/resolc-bin"

.github/workflows/release-llvm.yml

@@ -1,137 +0,0 @@
-name: Release LLVM
-on:
-  workflow_dispatch:
-    inputs:
-      llvm_version:
-        type: string
-        required: true
-        description: llvm version in "x.x.x" format, e.g. "18.1.8"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  create-release-draft:
-    runs-on: ubuntu-24.04
-    permissions:
-      contents: write
-    outputs:
-      version: ${{ steps.resolve-version.outputs.version }}
-    steps:
-      - id: resolve-version
-        run: |
-          echo "version=llvm-${{ inputs.llvm_version }}-revive.${GITHUB_SHA:0:7}" >> $GITHUB_OUTPUT
-
-      - name: Create Release
-        uses: softprops/action-gh-release@v2
-        with:
-          name: ${{ steps.resolve-version.outputs.version }}
-          body: "LLVM is a dependency of revive. The LLVM releases are used by our CI to build revive."
-          draft: true
-          tag_name: ${{ steps.resolve-version.outputs.version }}
-
-  build:
-    strategy:
-      matrix:
-        target: [x86_64-unknown-linux-gnu, x86_64-unknown-linux-musl, wasm32-unknown-emscripten, aarch64-apple-darwin, x86_64-apple-darwin, x86_64-pc-windows-msvc]
-        include:
-          - target: x86_64-unknown-linux-gnu
-            builder-arg: gnu
-            host: linux
-            runner: parity-large
-          - target: x86_64-unknown-linux-musl
-            builder-arg: musl
-            host: linux
-            runner: parity-large
-          - target: wasm32-unknown-emscripten
-            builder-arg: emscripten
-            host: linux
-            runner: parity-large
-          - target: aarch64-apple-darwin
-            builder-arg: gnu
-            host: macos
-            runner: macos-14
-          - target: x86_64-apple-darwin
-            builder-arg: gnu
-            host: macos
-            runner: macos-13
-          - target: x86_64-pc-windows-msvc
-            builder-arg: gnu
-            host: windows
-            runner: windows-2022
-    needs: create-release-draft
-    runs-on: ${{ matrix.runner }}
-    env:
-      RUST_LOG: trace
-    permissions:
-      contents: write # for uploading assets to release
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          # without this it will override our rust flags
-          rustflags: ""
-          cache-key: ${{ matrix.target }}
-
-      - name: Install Dependencies
-        if: ${{ matrix.host == 'linux' }}
-        run: |
-          sudo apt-get update && sudo apt-get install -y cmake ninja-build curl git libssl-dev pkg-config clang lld musl
-
-      - name: Install Dependencies
-        if: ${{ matrix.host == 'macos' }}
-        run: |
-          brew install ninja
-
-      - name: Install Dependencies
-        if: ${{ matrix.host == 'windows' }}
-        run: |
-          choco install ninja
-
-      - name: Install LLVM Builder
-        run: |
-          cargo install --locked --force --path crates/llvm-builder
-
-      - name: Clone LLVM
-        run: |
-          revive-llvm --target-env ${{ matrix.builder-arg }} clone
-
-      - name: Build LLVM
-        if: ${{ matrix.target != 'wasm32-unknown-emscripten' }}
-        run: |
-          revive-llvm --target-env ${{ matrix.builder-arg }} build --llvm-projects lld --llvm-projects clang
-
-      - name: Build LLVM
-        if: ${{ matrix.target == 'wasm32-unknown-emscripten' }}
-        run: |
-          source emsdk/emsdk_env.sh
-          revive-llvm --target-env ${{ matrix.builder-arg }} build --llvm-projects lld
-
-      - name: Remove Unnecessary Binaries
-        shell: bash
-        run: |
-          cd target-llvm/${{ matrix.builder-arg }}/target-final/bin/
-          rm -f diagtool* llvm-libtool-darwin* llvm-lipo* llvm-pdbutil* llvm-dwarfdump* llvm-nm* llvm-readobj* llvm-cfi-verify* \
-              sancov* llvm-debuginfo-analyzer* llvm-objdump* llvm-profgen* llvm-extract* llvm-jitlink* llvm-c-test* llvm-gsymutil* llvm-dwp* \
-              dsymutil* llvm-dwarfutil* llvm-exegesis* lli clang-rename* bugpoint* clang-extdef-mapping* clang-refactor* c-index-test* \
-              llvm-reduce* llvm-lto* clang-linker-wrapper* llc* llvm-lto2* llvm-otool* llvm-readelf* \
-              clang-repl* clang-check* clang-scan-deps*
-          cd -
-
-      - name: Package Artifact
-        shell: bash
-        run: |
-          mv target-llvm/${{ matrix.builder-arg }}/target-final/ llvm-${{ matrix.target }}
-          tar -czf "${{ needs.create-release-draft.outputs.version }}-${{ matrix.target }}.tar.gz" llvm-${{ matrix.target }}
-
-      - name: Add Artifact to Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: ${{ needs.create-release-draft.outputs.version }}
-          draft: true
-          files: |
-            ${{ needs.create-release-draft.outputs.version }}-${{ matrix.target }}.tar.gz

.github/workflows/release-nightly.yml

@@ -1,385 +0,0 @@
-name: Nightly Release
-on:
-  schedule:
-    # Run every day at 01:00 UTC
-    - cron: "0 1 * * *"
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067
-
-jobs:
-  # check if there were commits yesterday
-  check_commits:
-    runs-on: ubuntu-latest
-    outputs:
-      has_commits: ${{ steps.check_commits.outputs.has_commits }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Fetch full history to check previous commits
-          ref: "main"
-
-      - name: Check for commits from yesterday
-        id: check_commits
-        run: |
-          # Get yesterday's date in YYYY-MM-DD format
-          YESTERDAY=$(date -d "yesterday" +%Y-%m-%d)
-          echo "Checking for commits from: $YESTERDAY"
-
-          # Check if there were any commits yesterday
-          COMMIT_COUNT=$(git log --oneline --since="$YESTERDAY 00:00:00" --until="$YESTERDAY 23:59:59" | wc -l)
-
-          echo "Found $COMMIT_COUNT commits from yesterday"
-
-          if [ $COMMIT_COUNT -gt 0 ]; then
-            echo "has_commits=true" >> $GITHUB_OUTPUT
-            echo "✅ Found $COMMIT_COUNT commits from yesterday - continuing workflow"
-          else
-            echo "has_commits=false" >> $GITHUB_OUTPUT
-            echo "❌ No commits found from yesterday - skipping remaining steps"
-            echo "::notice::❌ No commits found from yesterday - skipping remaining steps"
-          fi
-
-  build:
-    # github actions matrix jobs don't support multiple outputs
-    # ugly workaround from https://github.com/orgs/community/discussions/17245#discussioncomment-11222880
-    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
-    outputs:
-      resolc-x86_64-unknown-linux-musl_url: ${{ steps.set-output.outputs.resolc-x86_64-unknown-linux-musl_url }}
-      resolc-x86_64-unknown-linux-musl_sha: ${{ steps.set-output.outputs.resolc-x86_64-unknown-linux-musl_sha }}
-      resolc-aarch64-apple-darwin_url: ${{ steps.set-output.outputs.resolc-aarch64-apple-darwin_url }}
-      resolc-aarch64-apple-darwin_sha: ${{ steps.set-output.outputs.resolc-aarch64-apple-darwin_sha }}
-      resolc-x86_64-apple-darwin_url: ${{ steps.set-output.outputs.resolc-x86_64-apple-darwin_url }}
-      resolc-x86_64-apple-darwin_sha: ${{ steps.set-output.outputs.resolc-x86_64-apple-darwin_sha }}
-      resolc-x86_64-pc-windows-msvc_url: ${{ steps.set-output.outputs.resolc-x86_64-pc-windows-msvc_url }}
-      resolc-x86_64-pc-windows-msvc_sha: ${{ steps.set-output.outputs.resolc-x86_64-pc-windows-msvc_sha }}
-    strategy:
-      matrix:
-        target:
-          [
-            x86_64-unknown-linux-musl,
-            aarch64-apple-darwin,
-            x86_64-apple-darwin,
-            x86_64-pc-windows-msvc,
-          ]
-        include:
-          - target: x86_64-unknown-linux-musl
-            type: musl
-            runner: ubuntu-24.04
-          - target: aarch64-apple-darwin
-            type: native
-            runner: macos-14
-          - target: x86_64-apple-darwin
-            type: native
-            runner: macos-13
-          - target: x86_64-pc-windows-msvc
-            type: native
-            runner: windows-2022
-    runs-on: ${{ matrix.runner }}
-    needs: [check_commits]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          # without this it will override our rust flags
-          rustflags: ""
-          cache-key: ${{ matrix.target }}
-
-      - name: Download LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: ${{ matrix.target }}
-
-      - name: Build
-        if: ${{ matrix.type == 'native' }}
-        shell: bash
-        run: |
-          export LLVM_SYS_181_PREFIX=$PWD/llvm-${{ matrix.target }}
-          make install-bin
-          mv target/release/resolc resolc-${{ matrix.target }} || mv target/release/resolc.exe resolc-${{ matrix.target }}.exe
-
-      - name: Build
-        if: ${{ matrix.type == 'musl' }}
-        run: |
-          docker run -v $PWD:/opt/revive $RUST_MUSL_CROSS_IMAGE /bin/bash -c "
-           cd /opt/revive
-           chown -R root:root .
-           apt update && apt upgrade -y && apt install -y pkg-config
-           export LLVM_SYS_181_PREFIX=/opt/revive/llvm-${{ matrix.target }}
-           make install-bin
-           mv target/${{ matrix.target }}/release/resolc resolc-${{ matrix.target }}
-           "
-          sudo chown -R $(id -u):$(id -g) .
-
-      - name: Install Solc
-        uses: ./.github/actions/get-solc
-
-      - name: Basic Sanity Check
-        shell: bash
-        run: |
-          result=$(./resolc-${{ matrix.target }} --bin crates/integration/contracts/flipper.sol)
-          echo $result
-          if [[ $result == *'0x50564d'* ]]; then exit 0; else exit 1; fi
-
-      - name: Upload artifacts (nightly)
-        uses: actions/upload-artifact@v4
-        id: artifact-upload-step
-        with:
-          name: resolc-${{ matrix.target }}
-          path: resolc-${{ matrix.target }}*
-          retention-days: 40
-
-      - name: Set output variables (nightly)
-        id: set-output
-        shell: bash
-        run: |
-          echo "Artifact URL is ${{ steps.artifact-upload-step.outputs.artifact-url }}"
-          echo "Artifact SHA is ${{ steps.artifact-upload-step.outputs.artifact-digest }}"
-          echo "resolc-${{ matrix.target }}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}"
-          echo "resolc-${{ matrix.target }}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}" >> "$GITHUB_OUTPUT"
-          echo "resolc-${{ matrix.target }}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}"
-          echo "resolc-${{ matrix.target }}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}" >> "$GITHUB_OUTPUT"
-
-  build-wasm:
-    runs-on: ubuntu-24.04
-    needs: [check_commits]
-    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
-    outputs:
-      resolc-web.js_url: ${{ steps.set-output.outputs.resolc_web_js_url }}
-      resolc-web.js_sha: ${{ steps.set-output.outputs.resolc_web_js_sha }}
-    env:
-      RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive/releases/download/${{ github.ref_name }}/resolc.wasm
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          target: wasm32-unknown-emscripten
-          # without this it will override our rust flags
-          rustflags: ""
-
-      - name: Download Host LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: x86_64-unknown-linux-gnu
-
-      - name: Download Wasm LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: wasm32-unknown-emscripten
-
-      - name: Download EMSDK
-        uses: ./.github/actions/get-emsdk
-
-      - name: Build
-        run: |
-          export LLVM_SYS_181_PREFIX=$PWD/llvm-x86_64-unknown-linux-gnu
-          export REVIVE_LLVM_TARGET_PREFIX=$PWD/llvm-wasm32-unknown-emscripten
-          source emsdk/emsdk_env.sh
-          make install-wasm
-          chmod -x ./target/wasm32-unknown-emscripten/release/resolc.wasm
-
-      - name: Set Up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "20"
-
-      - name: Basic Sanity Check
-        run: |
-          mkdir -p solc
-          curl -sSLo solc/soljson.js https://github.com/ethereum/solidity/releases/download/v0.8.30/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); }
-          "
-
-      - name: Compress Artifact
-        run: |
-          mkdir -p resolc-wasm32-unknown-emscripten
-          mv ./target/wasm32-unknown-emscripten/release/resolc.js ./resolc-wasm32-unknown-emscripten/
-          mv ./target/wasm32-unknown-emscripten/release/resolc.wasm ./resolc-wasm32-unknown-emscripten/
-          mv ./target/wasm32-unknown-emscripten/release/resolc_web.js ./resolc-wasm32-unknown-emscripten/
-
-      # There is no way to upload several files as several artifacts with a single upload-artifact step
-      # It's needed to have resolc_web.js separately for night builds for resolc-bin repo
-      # https://github.com/actions/upload-artifact/issues/331
-      - name: Upload artifact resolc.js (nightly)
-        uses: actions/upload-artifact@v4
-        with:
-          name: resolc.js
-          path: resolc-wasm32-unknown-emscripten/resolc.js
-          retention-days: 40
-
-      - name: Upload artifacts resolc.wasm (nightly)
-        uses: actions/upload-artifact@v4
-        with:
-          name: resolc.wasm
-          path: resolc-wasm32-unknown-emscripten/resolc.wasm
-          retention-days: 40
-
-      - name: Upload artifacts resolc_web.js (nightly)
-        uses: actions/upload-artifact@v4
-        id: artifact-upload-step
-        with:
-          name: resolc_web.js
-          path: resolc-wasm32-unknown-emscripten/resolc_web.js
-          retention-days: 40
-
-      - name: Set output variables
-        id: set-output
-        env:
-          TARGET: resolc_web_js
-        run: |
-          echo "Artifact URL is ${{ steps.artifact-upload-step.outputs.artifact-url }}"
-          echo "Artifact SHA is ${{ steps.artifact-upload-step.outputs.artifact-digest }}"
-          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}"
-          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}" >> "$GITHUB_OUTPUT"
-          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}""
-          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}"" >> "$GITHUB_OUTPUT"
-
-  create-macos-fat-binary:
-    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
-    needs: [build]
-    outputs:
-      resolc-universal-apple-darwin_url: ${{ steps.set-output.outputs.resolc-universal-apple-darwin_url }}
-      resolc-universal-apple-darwin_sha: ${{ steps.set-output.outputs.resolc-universal-apple-darwin_sha }}
-    runs-on: macos-14
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          merge-multiple: true
-
-      - name: Create macOS Fat Binary
-        run: |
-          lipo resolc-aarch64-apple-darwin resolc-x86_64-apple-darwin -create -output resolc-universal-apple-darwin
-
-      - name: Make Executable
-        run: |
-          chmod +x resolc-universal-apple-darwin
-
-      - uses: actions/upload-artifact@v4
-        id: artifact-upload-step
-        with:
-          name: resolc-universal-apple-darwin
-          path: resolc-universal-apple-darwin
-          retention-days: 40
-
-      - name: Set output variables
-        id: set-output
-        env:
-          TARGET: resolc-universal-apple-darwin
-        run: |
-          echo "Artifact URL is ${{ steps.artifact-upload-step.outputs.artifact-url }}"
-          echo "Artifact SHA is ${{ steps.artifact-upload-step.outputs.artifact-digest }}"
-          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}"
-          echo "${TARGET}_url=${{ steps.artifact-upload-step.outputs.artifact-url }}" >> "$GITHUB_OUTPUT"
-          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}""
-          echo "${TARGET}_sha=${{ steps.artifact-upload-step.outputs.artifact-digest }}"" >> "$GITHUB_OUTPUT"
-
-  generate-nightly-json:
-    runs-on: ubuntu-24.04
-    if: ${{ needs.check_commits.outputs.has_commits == 'true' }}
-    environment: tags
-    needs: [build-wasm, build, create-macos-fat-binary, check_commits]
-    steps:
-      - name: Checkout revive
-        uses: actions/checkout@v4
-        with:
-          path: revive
-
-      - name: Checkout resolc-bin
-        uses: actions/checkout@v4
-        with:
-          repository: paritytech/resolc-bin
-          path: resolc-bin
-
-      - name: Download Artifacts
-        uses: actions/download-artifact@v4
-        with:
-          merge-multiple: true
-          path: bins
-
-      - uses: actions/create-github-app-token@v1
-        id: app-token
-        with:
-          app-id: ${{ secrets.REVIVE_JSON_APP_ID }}
-          private-key: ${{ secrets.REVIVE_JSON_APP_KEY }}
-          owner: paritytech
-          repositories: resolc-bin
-
-      - name: Generate JSON
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TOKEN: ${{ steps.app-token.outputs.token }}
-          APP_NAME: "paritytech-revive-json"
-          Green: "\e[32m"
-          NC: "\e[0m"
-        run: |
-          echo '[' > data.json
-          echo '${{ toJSON(needs.build.outputs) }}' >> data.json
-          echo ',' >> data.json
-          echo '${{ toJSON(needs.build-wasm.outputs) }}' >> data.json
-          echo ',' >> data.json
-          echo '${{ toJSON(needs.create-macos-fat-binary.outputs) }}' >> data.json
-          echo ']' >> data.json
-          chmod +x bins/resolc-x86_64-unknown-linux-musl
-          export FIRST_SOLC_VERSION=$(./bins/resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 1 -d "," | tr -d ">=")
-          export LAST_SOLC_VERSION=$(./bins/resolc-x86_64-unknown-linux-musl --supported-solc-versions | cut -f 2 -d "," | tr -d "<=")
-          export FILEPATH=$(readlink -f data.json)
-          export TAG=$(cd revive;gh release list --json name,isLatest --jq '.[] | select(.isLatest)|.name')
-          cd resolc-bin
-          mkdir -p nightly
-          cd nightly
-          python3 ../../revive/.github/scripts/json_generator_nightly.py
-          cd ..
-          git status
-
-          echo "${Green}Add new remote with gh app token${NC}"
-          git remote set-url origin $(git config remote.origin.url | sed "s/github.com/${APP_NAME}:${TOKEN}@github.com/g")
-
-          echo "${Green}Remove http section that causes issues with gh app auth token${NC}"
-          sed -i.bak '/\[http/d' ./.git/config
-          sed -i.bak '/extraheader/d' ./.git/config
-
-          git config user.email "ci@parity.io"
-          git config user.name "${APP_NAME}"
-
-          git add nightly/
-          git commit -m "Update nightly json"
-          git push origin main
-
-          echo "::notice::nightly info.list files were successfully published to https://github.com/paritytech/resolc-bin"

.github/workflows/release.yml

@@ -1,329 +0,0 @@
-name: Build & Release
-on:
-  push:
-    branches: ["main"]
-    tags:
-      - "v*"
-  pull_request:
-    branches: ["main"]
-    types: [opened, synchronize, labeled, unlabeled]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-  # if changed, dont forget to update the env var in release-nightly.yml
-  RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067
-
-jobs:
-  check-version-changed:
-    runs-on: ubuntu-24.04
-    permissions:
-      contents: write
-    env:
-      CURRENT_TAG: ${{ github.ref_name }}
-    outputs:
-      RELEASE_NOTES: ${{ steps.versions.outputs.RELEASE_NOTES }}
-    steps:
-      - uses: actions/checkout@v4
-
-      # Check that tag and version in Cargo.toml match
-      - name: Check versions
-        id: versions
-        run: |
-          if [[ $CURRENT_TAG == 'main' ]];
-            then
-              echo "::notice::Tag $CURRENT_TAG is not a release tag, skipping the check in the main branch";
-              exit 0
-            fi
-
-          if [[ $CURRENT_TAG != "v"* ]];
-            then
-              echo "::notice::Tag $CURRENT_TAG is not a release tag, skipping the check in a PR";
-              exit 0
-            fi
-
-          export PKG_VER=v$(cat crates/resolc/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"
-          #
-          if [[ $CURRENT_TAG != $PKG_VER  ]];
-            then
-              echo "::error::Tag $CURRENT_TAG doesn't match package version $PKG_VER in Cargo.toml, please fix";
-              exit 1
-            fi
-
-          # Generating release notes early, in order to avoid checkout at the last step
-          export RELEASE_NOTES="$(sed '/^## '${CURRENT_TAG}'/,/^## v/!d' CHANGELOG.md | sed -e '1d' -e '$d')"
-
-          echo "Release notes:"
-          echo "$RELEASE_NOTES"
-
-          echo 'RELEASE_NOTES<<EOF' >> $GITHUB_OUTPUT
-          echo "$RELEASE_NOTES" >> $GITHUB_OUTPUT
-          echo 'EOF' >> $GITHUB_OUTPUT
-
-  build:
-    strategy:
-      matrix:
-        target:
-          [
-            x86_64-unknown-linux-musl,
-            aarch64-apple-darwin,
-            x86_64-apple-darwin,
-            x86_64-pc-windows-msvc,
-          ]
-        include:
-          - target: x86_64-unknown-linux-musl
-            type: musl
-            runner: ubuntu-24.04
-          - target: aarch64-apple-darwin
-            type: native
-            runner: macos-14
-          - target: x86_64-apple-darwin
-            type: native
-            runner: macos-13
-          - target: x86_64-pc-windows-msvc
-            type: native
-            runner: windows-2022
-    runs-on: ${{ matrix.runner }}
-    needs: [check-version-changed]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          # without this it will override our rust flags
-          rustflags: ""
-          cache-key: ${{ matrix.target }}
-
-      - name: Download LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: ${{ matrix.target }}
-
-      - name: Build
-        if: ${{ matrix.type == 'native' }}
-        shell: bash
-        run: |
-          export LLVM_SYS_181_PREFIX=$PWD/llvm-${{ matrix.target }}
-          make install-bin
-          mv target/release/resolc resolc-${{ matrix.target }} || mv target/release/resolc.exe resolc-${{ matrix.target }}.exe
-
-      - name: Build
-        if: ${{ matrix.type == 'musl' }}
-        run: |
-          docker run -v $PWD:/opt/revive $RUST_MUSL_CROSS_IMAGE /bin/bash -c "
-           cd /opt/revive
-           chown -R root:root .
-           apt update && apt upgrade -y && apt install -y pkg-config
-           export LLVM_SYS_181_PREFIX=/opt/revive/llvm-${{ matrix.target }}
-           make install-bin
-           mv target/${{ matrix.target }}/release/resolc resolc-${{ matrix.target }}
-           "
-          sudo chown -R $(id -u):$(id -g) .
-
-      - name: Install Solc
-        uses: ./.github/actions/get-solc
-
-      - name: Basic Sanity Check
-        shell: bash
-        run: |
-          result=$(./resolc-${{ matrix.target }} --bin crates/integration/contracts/flipper.sol)
-          echo $result
-          if [[ $result == *'0x50564d'* ]]; then exit 0; else exit 1; fi
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: resolc-${{ matrix.target }}
-          path: resolc-${{ matrix.target }}*
-          retention-days: 1
-
-  build-wasm:
-    runs-on: ubuntu-24.04
-    needs: [check-version-changed]
-    env:
-      RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive/releases/download/${{ github.ref_name }}/resolc.wasm
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          target: wasm32-unknown-emscripten
-          # without this it will override our rust flags
-          rustflags: ""
-
-      - name: Download Host LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: x86_64-unknown-linux-gnu
-
-      - name: Download Wasm LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: wasm32-unknown-emscripten
-
-      - name: Download EMSDK
-        uses: ./.github/actions/get-emsdk
-
-      - name: Build
-        run: |
-          export LLVM_SYS_181_PREFIX=$PWD/llvm-x86_64-unknown-linux-gnu
-          export REVIVE_LLVM_TARGET_PREFIX=$PWD/llvm-wasm32-unknown-emscripten
-          source emsdk/emsdk_env.sh
-          make install-wasm
-          chmod -x ./target/wasm32-unknown-emscripten/release/resolc.wasm
-
-      - name: Set Up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "20"
-
-      - name: Basic Sanity Check
-        run: |
-          mkdir -p solc
-          curl -sSLo solc/soljson.js https://github.com/ethereum/solidity/releases/download/v0.8.30/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); }
-          "
-
-      - name: Compress Artifact
-        run: |
-          mkdir -p resolc-wasm32-unknown-emscripten
-          mv ./target/wasm32-unknown-emscripten/release/resolc.js ./resolc-wasm32-unknown-emscripten/
-          mv ./target/wasm32-unknown-emscripten/release/resolc.wasm ./resolc-wasm32-unknown-emscripten/
-          mv ./target/wasm32-unknown-emscripten/release/resolc_web.js ./resolc-wasm32-unknown-emscripten/
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: resolc-wasm32-unknown-emscripten
-          path: resolc-wasm32-unknown-emscripten/*
-          retention-days: 1
-
-  create-release:
-    if: startsWith(github.ref_name, 'v')
-    needs: [check-version-changed, build-wasm]
-    runs-on: macos-14
-    environment: tags
-    steps:
-      - name: Download Artifacts
-        uses: actions/download-artifact@v4
-        with:
-          merge-multiple: true
-
-      - name: Create macOS Fat Binary
-        run: |
-          lipo resolc-aarch64-apple-darwin resolc-x86_64-apple-darwin -create -output resolc-universal-apple-darwin
-
-      - name: Make Executable
-        run: |
-          chmod +x resolc-x86_64-unknown-linux-musl
-          chmod +x resolc-universal-apple-darwin
-
-      - name: Create sha-256 checksum
-        run: |
-          shasum -a 256 resolc-x86_64-unknown-linux-musl > checksums.txt
-          shasum -a 256 resolc-universal-apple-darwin >> checksums.txt
-          shasum -a 256 resolc-x86_64-pc-windows-msvc.exe >> checksums.txt
-          shasum -a 256 resolc.js >> checksums.txt
-          shasum -a 256 resolc.wasm >> checksums.txt
-          shasum -a 256 resolc_web.js >> checksums.txt
-
-      - uses: actions/create-github-app-token@v1
-        id: app-token
-        with:
-          app-id: ${{ secrets.REVIVE_RELEASE_APP_ID }}
-          private-key: ${{ secrets.REVIVE_RELEASE_APP_KEY }}
-
-      - name: create-release
-        uses: softprops/action-gh-release@v2
-        with:
-          body: |
-            ## Changelog
-            ${{ needs.check-version-changed.outputs.RELEASE_NOTES }}
-
-            ## Note for macOS Users
-            The macOS binary is unsigned and it needs to be made runnable using `xattr -c resolc-universal-apple-darwin`.
-          tag_name: ${{ github.ref_name }}
-          name: ${{ github.ref_name }}
-          prerelease: true
-          token: ${{ steps.app-token.outputs.token }}
-          target_commitish: ${{ github.sha }}
-          files: |
-            resolc-x86_64-unknown-linux-musl
-            resolc-universal-apple-darwin
-            resolc-x86_64-pc-windows-msvc.exe
-            resolc.js
-            resolc.wasm
-            resolc_web.js
-            checksums.txt
-
-  npm-release:
-    needs: [create-release]
-    runs-on: macos-14
-    environment: tags
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Download Artifacts
-        uses: actions/download-artifact@v4
-        with:
-          merge-multiple: true
-
-      - name: Set Up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "20"
-
-      - run: npm ci -w js/resolc
-
-      - name: Build
-        run: |
-          cp -f resolc.{wasm,js} js/resolc/src/resolc
-          npm -w js/resolc run build
-
-      - name: npm pack
-        run: npm -w js/resolc pack
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: npm_package
-          path: "parity-resolc-*.tgz"
-
-      - uses: octokit/request-action@bbedc70b1981e610d89f1f8de88311a1fc02fb83
-        with:
-          route: POST /repos/paritytech/npm_publish_automation/actions/workflows/publish.yml/dispatches
-          ref: main
-          inputs: '${{ format(''{{ "artifact_name": "npm_package", "repo": "{0}", "run_id": "{1}" }}'', github.repository, github.run_id) }}'
-        env:
-          GITHUB_TOKEN: ${{ secrets.NPM_PUBLISH_AUTOMATION_TOKEN }}

.github/workflows/test-llvm-builder.yml

@@ -1,45 +0,0 @@
-name: Test LLVM Builder
-on:
-  pull_request:
-    branches: ["main"]
-    types: [opened, synchronize]
-    paths:
-      - 'LLVM.lock'
-      - 'crates/llvm-builder/**'
-      - '.github/workflows/test-llvm-builder.yml'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  test:
-    strategy:
-      matrix:
-        runner: [parity-large, macos-14, windows-2022]
-    runs-on: ${{ matrix.runner }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          # without this it will override our rust flags
-          rustflags: ""
-          cache-key: ${{ matrix.runner }}
-
-      - name: Install Dependencies
-        if: matrix.runner == 'parity-large'
-        run: |
-          sudo apt update && sudo apt-get install -y cmake ninja-build curl git libssl-dev pkg-config clang lld musl
-
-      - name: Install Dependencies
-        if: matrix.runner == 'macos-14'
-        run: |
-          brew install ninja
-
-      - name: Test
-        run: make test-llvm-builder
-        env:
-          RUST_LOG: trace

.github/workflows/test-wasm.yml

@@ -1,103 +0,0 @@
-name: Test Wasm Version
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-    types: [opened, synchronize]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-  REVIVE_WASM_INSTALL_DIR: ${{ github.workspace }}/target/wasm32-unknown-emscripten/release
-
-jobs:
-  build:
-    runs-on: ubuntu-24.04
-    defaults:
-      run:
-        shell: bash
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          target: wasm32-unknown-emscripten
-          # without this it will override our rust flags
-          rustflags: ""
-
-      - name: Download Host LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: x86_64-unknown-linux-gnu
-
-      - name: Download Wasm LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: wasm32-unknown-emscripten
-
-      - name: Install emsdk
-        uses: ./.github/actions/get-emsdk
-
-      - name: Set LLVM Environment Variables
-        run: |
-          echo "LLVM_SYS_181_PREFIX=$(pwd)/llvm-x86_64-unknown-linux-gnu" >> $GITHUB_ENV
-          echo "REVIVE_LLVM_TARGET_PREFIX=$(pwd)/llvm-wasm32-unknown-emscripten" >> $GITHUB_ENV
-
-      - 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:
-    needs: build
-    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 Node Packages
-        run: npm install
-
-      - name: Test emscripten
-        run: |
-          echo "Running tests for ${{ matrix.os }}"
-          npm run test:wasm
-
-      - name: Test @parity/resolc
-        run: |
-          echo "Running tests for ${{ matrix.os }}"
-          npm run -w js/resolc test
-
-      - name: Run Playwright tests
-        run: |
-          cd js/emscripten
-          npx playwright install --with-deps
-          npx playwright test

.github/workflows/test.yml

@@ -1,57 +0,0 @@
-name: Test
-on:
-  push:
-    branches: ["main"]
-  pull_request:
-    branches: ["main"]
-    types: [opened, synchronize]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  test:
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          # without this it will override our rust flags
-          rustflags: ""
-
-      - name: Install Solc
-        uses: ./.github/actions/get-solc
-
-      - name: Download LLVM
-        uses: ./.github/actions/get-llvm
-        with:
-          target: x86_64-unknown-linux-gnu
-
-      - name: Set LLVM Environment Variables
-        run: |
-          echo "LLVM_SYS_181_PREFIX=$(pwd)/llvm-x86_64-unknown-linux-gnu" >> $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@v0.7.1
-
-      - 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

.gitignore

@@ -1,21 +0,0 @@
-/target
-/js/resolc/dist
-target-llvm
-*.dot
-.vscode/
-.DS_Store
-/*.sol
-/*.yul
-/*.ll
-/*.s
-/llvm*
-node_modules
-artifacts
-tmp
-/*.html
-/build
-soljson.js
-test-results
-playwright-report
-.cache
-emsdk

.prettierrc.json

@@ -1,6 +0,0 @@
-{
-  "trailingComma": "es5",
-  "tabWidth": 2,
-  "semi": false,
-  "singleQuote": true
-}

CHANGELOG.md

@@ -1,298 +0,0 @@
-# Changelog
-
-## Unreleased
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev: `2503.0.1`
-
-## v0.4.0
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev: `2503.0.1`
-
-### Added
-- Line debug information per YUL builtin and for `if` statements.
-- Column numbers in debug information.
-- Support for the YUL optimizer details in the standard json input definition.
-- The `revive-explorer` compiler utility.
-
-### Fixed
-- The debug info source file matches the YUL path in `--debug-output-dir`, allowing tools to display the source line. 
-
-## v0.3.0
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev: `2503.0.1`
-
-### Fixed
-
-- llvm-context: Bugfix the SAR YUL builtin translation.
-- runtime-api: Add the missing `memset` builtin.
-- npm package: Bugfix the exports field defined in the `package.json`.
-
-
-## v0.2.0
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev: `2503.0.1`
-
-### Changed
-
-- Removed the license printer from the `resolc` binary.
-- EVM bytecode is no longer requested from solc (except in test utils) leading to less compilation work in the pipeline.
-
-### Fixed
-
-- solc-json-interface: Serializing of any custom key in the JSON input is only skipped if not provided.
-- npm package resolution no longer fails with an 'ERR_PACKAGE_PATH_NOT_EXPORTED' error for packages defining exports fields in the `package.json`.
-
-## v0.1.0
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev: `2503.0.1`
-
-### Added
-
-- Add the PolkaVM heap size, stack size and debug info CLI compiler options to the standard JSON settings. This makes the standard JSON input succint for reproducible builds.
-
-### Changed
-
-- Supported `polkadot-sdk` version is now `2503.0.1`
-- The `emsdk` version is now `4.0.9`
-
-### Fixed
-
-## v0.1.0-dev.16
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`
-
-### Added
-
-- Move the npm package from paritytech/js-revive, into this repo. The package `@parity/resolc` will be deployed to npm for each release.
-- Support for solc v0.8.30
-
-### Changed
-
-- By default, heavy size optimizations are applied.
-
-### Fixed
-
-- @parity/resolc: The solc dependency package is constrained to the latest supported version, preventing breaking the package ever time a new solc package was released. 
-- The resolc npm package no longer ignores the optimizer settings
-
-## v0.1.0-dev.14
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`
-
-### Added
-
-- The `revive-runner` helper utility binary which helps to run contracts locally without a blockchain node.
-- Allow configuration of the EVM heap memory size and stack size via CLI flags and JSON input settings.
-
-### Changed
-
-- The default PVM stack memory size was increased from 16kb to 32kb.
-
-### Fixed
-
-- Constructors avoid storing zero sized immutable data on exit.
-
-## v0.1.0-dev.13
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`
-
-### Added
-
-- Support for solc v0.8.29
-- Decouples the solc JSON-input-output type definitions from the Solidity fronted and expose them via a dedicated crate.
-- `--supported-solc-versions` for `resolc` binary to return a `semver` range of supported `solc` versions.
-- Support for passing LLVM command line options via the prcoess input or providing one or more `--llvm-arg='..'` resolc CLI flag. This allows more fine-grained control over the LLVM backend configuration.
-
-### Changed
-
-- Storage keys and values are big endian. This was a pre-mature optimization because for the contract itself it this is a no-op and thus not observable. However we should consider the storage layout as part of the contract ABI. The endianness of transient storage values are still kept as-is.
-- Running `resolc` using webkit is no longer supported.
-
-### Fixed
-
-- A missing byte swap for the create2 salt value.
-
-## v0.1.0-dev.12
-
-This is a development pre-release.
-
-Supported `polkadot-sdk` rev: `21f6f0705e53c15aa2b8a5706b208200447774a9`
-
-### Added
-
-- Per file output selection for `--standard-json` mode.
-- The `ir` output selection option for `--standard-json` mode.
-
-### Changed
-
-- Improved code size: Large contracts compile to smaller code blobs when enabling aggressive size optimizations (`-Oz`).
-
-### Fixed
-
-## 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

Cargo.toml

@@ -1,89 +0,0 @@
-[workspace]
-resolver = "2"
-members = ["crates/*"]
-
-[workspace.package]
-version = "0.1.0"
-authors = [
-    "Cyrill Leutwiler <cyrill@parity.io>",
-    "Parity Technologies <admin@parity.io>",
-]
-license = "MIT/Apache-2.0"
-edition = "2021"
-repository = "https://github.com/paritytech/revive"
-rust-version = "1.85.0"
-
-[workspace.dependencies]
-resolc = { version = "0.3.0", path = "crates/resolc" }
-revive-benchmarks = { version = "0.1.0", path = "crates/benchmarks" }
-revive-builtins = { version = "0.1.0", path = "crates/builtins" }
-revive-common = { version = "0.1.0", path = "crates/common" }
-revive-differential = { version = "0.1.0", path = "crates/differential" }
-revive-explorer = { version = "0.1.0", path = "crates/explore" }
-revive-integration = { version = "0.1.1", path = "crates/integration" }
-revive-linker = { version = "0.1.0", path = "crates/linker" }
-lld-sys = { version = "0.1.0", path = "crates/lld-sys" }
-revive-llvm-context = { version = "0.3.0", path = "crates/llvm-context" }
-revive-runtime-api = { version = "0.2.0", path = "crates/runtime-api" }
-revive-runner = { version = "0.1.0", path = "crates/runner" }
-revive-solc-json-interface = { version = "0.2.0", path = "crates/solc-json-interface" }
-revive-stdlib = { version = "0.1.1", path = "crates/stdlib" }
-revive-build-utils = { version = "0.1.0", path = "crates/build-utils" }
-revive-yul = { version = "0.2.1", path = "crates/yul" }
-
-hex = "0.4.3"
-cc = "1.2"
-libc = "0.2.172"
-tempfile = "3.20"
-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.11"
-once_cell = "1.21"
-num = "0.4.3"
-sha1 = "0.10"
-sha3 = "0.10"
-thiserror = "2.0"
-which = "7.0"
-path-slash = "0.2"
-rayon = "1.10"
-clap = { version = "4", default-features = false, features = ["derive"] }
-polkavm-common = "0.24.0"
-polkavm-linker = "0.24.0"
-polkavm-disassembler = "0.24.0"
-polkavm = "0.24.0"
-alloy-primitives = { version = "1.1", features = ["serde"] }
-alloy-sol-types = "1.1"
-alloy-genesis = "1.0"
-alloy-serde = "1.0"
-env_logger = { version = "0.11.8", default-features = false }
-serde_stacker = "0.1.12"
-criterion = { version = "0.6", features = ["html_reports"] }
-log = { version = "0.4.27" }
-git2 = { version = "0.20.2", default-features = false }
-downloader = "0.2.8"
-flate2 = "1.1"
-fs_extra = "1.3"
-num_cpus = "1"
-tar = "0.4"
-toml = "0.8"
-assert_cmd = "2.0"
-assert_fs = "1.1"
-
-# polkadot-sdk and friends
-codec = { version = "3.7.5", default-features = false, package = "parity-scale-codec" }
-scale-info = { version = "2.11.6", default-features = false }
-polkadot-sdk = { version = "2503.0.1" }
-
-# llvm
-[workspace.dependencies.inkwell]
-version = "0.6.0"
-default-features = false
-features = ["serde", "llvm18-1", "no-libffi-linking", "target-riscv"]
-
-[profile.bench]
-inherits = "release"
-lto = true
-codegen-units = 1

Dockerfile

@@ -1,32 +0,0 @@
-FROM rust:1.85.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@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067 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 

LICENSE-APACHE

@@ -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.

LICENSE-MIT

@@ -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.

LLVM.lock

@@ -1,3 +0,0 @@
-url = "https://github.com/llvm/llvm-project.git"
-branch = "release/18.x"
-ref = "3b5b5c1ec4a3095ab096dd780e84d7ab81f3d7ff"

Makefile

@@ -1,99 +0,0 @@
-.PHONY: \
-	install \
-	install-bin \
-	install-npm \
-	install-wasm \
-	install-llvm-builder \
-	install-llvm \
-	install-revive-runner \
-	install-revive-explorer \
-	format \
-	clippy \
-	machete \
-	test \
-	test-integration \
-	test-resolc \
-	test-workspace \
-	test-cli \
-	test-wasm \
-	test-llvm-builder
-	bench \
-	bench-pvm \
-	bench-evm \
-	clean
-
-install: install-bin install-npm
-
-install-bin:
-	cargo install --force --locked --path crates/resolc
-
-install-npm:
-	npm install && npm fund
-
-install-wasm: install-npm
-	cargo build --target wasm32-unknown-emscripten -p resolc --release --no-default-features
-	npm run build:package
-
-install-llvm-builder:
-	cargo install --force --locked --path crates/llvm-builder
-
-install-llvm: install-llvm-builder
-	revive-llvm clone
-	revive-llvm build --llvm-projects lld --llvm-projects clang
-
-install-revive-runner:
-	cargo install --locked --force --path crates/runner --no-default-features
-
-install-revive-explorer:
-	cargo install --locked --force --path crates/explorer --no-default-features
-
-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 install-revive-runner install-revive-explorer
-
-test-integration: install-bin
-	cargo test --package revive-integration
-
-test-resolc: install
-	cargo test --package resolc
-
-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/resolc/src/tests/cli-tests/artifacts ; \
-	cargo uninstall resolc ; \
-	cargo uninstall revive-llvm-builder ;

README.md

@@ -1,146 +0,0 @@
-![CI](https://github.com/paritytech/revive/actions/workflows/test.yml/badge.svg)
-[![Docs](https://img.shields.io/badge/Docs-contracts.polkadot.io-brightgreen.svg)](https://contracts.polkadot.io/revive_compiler/)
-
-# 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
-Building Solidity contracts for PolkaVM requires installing the following two compilers:
-- `resolc`: The revive Solidity compiler YUL frontend and PolkaVM code generator (provided by this repository).
-- `solc`: The [Ethereum Solidity reference compiler](https://github.com/ethereum/solidity/) implemenation.`resolc` uses `solc` during the compilation process, please refer to the [Ethereum Solidity documentation](https://docs.soliditylang.org/en/latest/installing-solidity.html) for installation instructions.
-
-### `resolc` binary releases
-`resolc` is distributed as a standalone binary (with `solc` as the only external dependency). Please download one of our [binary releases](https://github.com/paritytech/revive/releases) for your target platform and mind the platform specific instructions below.
-
-<details>
-  <summary>MacOS users</summary>
-
-> **MacOS** users need to clear the `downloaded` attribute from the binary and set the executable flag.
-> ```sh
-> xattr -rc resolc-universal-apple-darwin
-> chmod +x resolc-universal-apple-darwin
-> ```
-
-</details>
-
-<details>
-  <summary>Linux users</summary>
-
-> **Linux** users need to set the executable flag.
-> ```sh
-> chmod +x resolc-x86_64-unknown-linux-musl
-> ```
-
-</details>
-
-
-### `resolc` NPM package
-We distribute the revive compiler as [node.js module](https://www.npmjs.com/package/@parity/resolc) and [hardhat plugin](https://www.npmjs.com/package/@parity/hardhat-polkadot-resolc).
-
-Note: The `solc` dependency is bundled via NPM packaging and defaults to the latest supported version.
-
-## 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. You can either download a build from our releases (recommended for older hardware) or build it from source.
-
-<details>
-  <summary>Download from our LLVM releases</summary>
-
-Download the [latest LLVM build](https://github.com/paritytech/revive/releases?q=LLVM+binaries+release&expanded=true) from our releases.
-
-> **MacOS** users need to clear the `downloaded` attribute from all binaries after extracting the archive:
-> ```sh
-> xattr -rc </path/to/the/extracted/archive>/target-llvm/gnu/target-final/bin/*
-> ```
-
-After extracting the archive, point `$LLVM_SYS_181_PREFIX` to it:
-```sh
-export LLVM_SYS_181_PREFIX=</path/to/the/extracted/archive>/target-llvm/gnu/target-final
-```
-
-</details>
-
-<details>
-  <summary>Building from source</summary>
-
- 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:
-
-```sh
-make install-llvm
-export LLVM_SYS_181_PREFIX=${PWD}/target-llvm/gnu/target-final
-```
-
-</details>
-
-### The `resolc` Solidity frontend
-
-To build the `resolc` Solidity frontend executable, make sure you have obtained a compatible LLVM build and did export the `LLVM_SYS_181_PREFIX` environment variable pointing to it (see [above](#LLVM)).
-
-To install the `resolc` Solidity frontend executable:
-
-```sh
-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.
-
-<details>
-  <summary>Instructions for cross-compilation to wasm32-unknown-emscripten</summary>
-
-```sh
-# 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
-```
-
-</details>
-
-## 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
-See the [relevant section in our documentation](https://contracts.polkadot.io/revive_compiler/architecture) to learn more about how the compiler works. 
-
-### 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:
-
-```sh
-make test
-```
-# Acknowledgements
-
-The revive compiler project, after some early experiments with EVM bytecode translations, decided to fork the `era-compiler` framework.
-[Frontend](https://github.com/matter-labs/era-compiler-solidity), [code generator](https://github.com/matter-labs/era-compiler-llvm-context) and some supporting libraries are based of ZKSync `zksolc`. I'd like to express my gratitude and thank the original authors for providing a useable code base under a generous license.
-

RELEASE.md

@@ -1,29 +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. Create a release PR which, if necessary:
-  - Updates the versions in the workspace `Cargo.toml`
-  - Updates the version in each crate `Cargo.toml`
-  - Updates the version of the NPM package in `js/resolc/package.json`
-  - Updates the `CHANGELOG.md` to reflect all observable changes
-2. If the CI passes, merge the release PR.
-3. Push a `vX.Y.Z` tag that has the same version as in `Cargo.toml`
-4. The release workflow will attempt to build and publish a new pre-release if the latest tag does match the cargo package version.
-5. Wait for the `Release` workflow to finish. It should create the pre-release with the same name.
-6. Check that pre-release was created on the [Releases page](https://github.com/paritytech/revive/releases) with all artifacts.
-7. After the release is published, another workflow should start automatically and update json files in https://github.com/paritytech/resolc-bin. Check the changes.
-8. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly
-
-# `resolc` NPM package release
-
-Will happen automatically.
-
-# LLVM release
-
-To create a new LLVM release, run "Release LLVM" workflow. Use current LLVM version as parameter, e.g. `18.1.8`.
-Version suffix will be resolved automatically.  
-The workflows will create new GitHub release, and upload LLVM binaries.
-Next release of resolc will use newly created binaries.  

SECURITY.md

@@ -1 +0,0 @@
-https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/SECURITY.md

crates/benchmarks/BENCHMARKS.md

@@ -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`** | `10.08 us` (✅ **1.00x**) | `10.32 us` (✅ **1.02x slower**)  |
-
-### OddPorduct
-
-|              | `EVM`                     | `PVMInterpreter`                 |
-|:-------------|:--------------------------|:-------------------------------- |
-| **`10000`**  | `3.60 ms` (✅ **1.00x**)   | `1.57 ms` (🚀 **2.28x faster**)   |
-| **`100000`** | `34.72 ms` (✅ **1.00x**)  | `14.82 ms` (🚀 **2.34x faster**)  |
-| **`300000`** | `105.01 ms` (✅ **1.00x**) | `44.11 ms` (🚀 **2.38x faster**)  |
-
-### TriangleNumber
-
-|              | `EVM`                    | `PVMInterpreter`                 |
-|:-------------|:-------------------------|:-------------------------------- |
-| **`10000`**  | `2.43 ms` (✅ **1.00x**)  | `1.12 ms` (🚀 **2.17x faster**)   |
-| **`100000`** | `24.20 ms` (✅ **1.00x**) | `10.86 ms` (🚀 **2.23x faster**)  |
-| **`360000`** | `88.69 ms` (✅ **1.00x**) | `38.46 ms` (🚀 **2.31x faster**)  |
-
-### FibonacciRecursive
-
-|          | `EVM`                     | `PVMInterpreter`                  |
-|:---------|:--------------------------|:--------------------------------- |
-| **`12`** | `144.17 us` (✅ **1.00x**) | `150.85 us` (✅ **1.05x slower**)  |
-| **`16`** | `938.71 us` (✅ **1.00x**) | `922.11 us` (✅ **1.02x faster**)  |
-| **`20`** | `6.54 ms` (✅ **1.00x**)   | `6.20 ms` (✅ **1.05x faster**)    |
-| **`24`** | `45.73 ms` (✅ **1.00x**)  | `41.98 ms` (✅ **1.09x faster**)   |
-
-### FibonacciIterative
-
-|           | `EVM`                    | `PVMInterpreter`                 |
-|:----------|:-------------------------|:-------------------------------- |
-| **`64`**  | `23.00 us` (✅ **1.00x**) | `31.88 us` (❌ *1.39x slower*)    |
-| **`128`** | `35.28 us` (✅ **1.00x**) | `42.43 us` (❌ *1.20x slower*)    |
-| **`256`** | `60.12 us` (✅ **1.00x**) | `61.20 us` (✅ **1.02x slower**)  |
-
-### FibonacciBinet
-
-|           | `EVM`                    | `PVMInterpreter`                 |
-|:----------|:-------------------------|:-------------------------------- |
-| **`64`**  | `23.01 us` (✅ **1.00x**) | `47.74 us` (❌ *2.07x slower*)    |
-| **`128`** | `25.44 us` (✅ **1.00x**) | `49.67 us` (❌ *1.95x slower*)    |
-| **`256`** | `28.66 us` (✅ **1.00x**) | `53.01 us` (❌ *1.85x slower*)    |
-
-### SHA1
-
-|           | `EVM`                     | `PVMInterpreter`                  |
-|:----------|:--------------------------|:--------------------------------- |
-| **`1`**   | `135.87 us` (✅ **1.00x**) | `243.75 us` (❌ *1.79x slower*)    |
-| **`64`**  | `258.45 us` (✅ **1.00x**) | `355.70 us` (❌ *1.38x slower*)    |
-| **`512`** | `1.10 ms` (✅ **1.00x**)   | `1.09 ms` (✅ **1.01x faster**)    |
-
----
-Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
-

crates/benchmarks/Cargo.toml

@@ -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

crates/benchmarks/benches/execute.rs

@@ -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);

crates/benchmarks/src/lib.rs

@@ -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
-}

crates/build-utils/.gitignore

@@ -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/

crates/build-utils/Cargo.toml

@@ -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]

crates/build-utils/README.md

@@ -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.

crates/build-utils/src/lib.rs

@@ -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()))
-}

crates/builtins/Cargo.toml

@@ -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 }

crates/builtins/build.rs

@@ -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");
-}

crates/builtins/src/lib.rs

@@ -1 +0,0 @@
-include!(concat!(env!("OUT_DIR"), "/compiler_rt.rs"));

crates/common/.gitignore

@@ -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/

crates/common/Cargo.toml

@@ -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 }

crates/common/README.md

@@ -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.

crates/common/src/base.rs

@@ -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;

crates/common/src/bit_length.rs

@@ -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;

crates/common/src/byte_length.rs

@@ -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;

crates/common/src/evm_version.rs

@@ -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"),
-        }
-    }
-}

crates/common/src/exit_code.rs

@@ -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;

crates/common/src/extension.rs

@@ -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";

crates/common/src/lib.rs

@@ -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::*;

crates/common/src/utils.rs

@@ -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)
-}

crates/differential/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "revive-differential"
-description = "utilities for differential testing the revive compiler against EVM"
-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 }

crates/differential/genesis.json

@@ -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"
-        }
-    }
-}

crates/differential/src/go_duration.rs

@@ -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")),
-        );
-    }
-}

crates/differential/src/lib.rs

@@ -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));
-    }
-}

crates/explorer/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "revive-explorer"
-version.workspace = true
-license.workspace = true
-edition.workspace = true
-repository.workspace = true
-authors.workspace = true
-description = "Helper utility to inspect debug builds"
-
-[[bin]]
-name = "revive-explorer"
-path = "src/main.rs"
-
-[dependencies]
-anyhow = { workspace = true }
-clap = { workspace = true, features = ["help", "std", "derive"] }
-num_cpus = { workspace = true }
-
-revive-yul = { workspace = true }
-

crates/explorer/README.md

@@ -1,49 +0,0 @@
-# revive-explorer
-
-The `revive-explorer` is a helper utility for exploring the compilers YUL lowering unit.
-
-It analyzes a given shared objects from the debug dump and outputs:
-- The count of each YUL statement translated.
-- A per YUL statement break-down of bytecode size contributed per.
-- Estimated `yul-phaser` cost parameters.
-
-Example:
-
-```
-statements count:
-	block 532
-	Caller 20
-	Not 73
-	Gas 24
-	Shr 2
-    ...
-	Shl 259
-	SetImmutable 2
-	CodeSize 1
-	CallDataLoad 87
-	Return 56
-bytes per statement:
-	Or 756
-	CodeCopy 158
-	Log3 620
-	Return 1562
-	MStore 36128
-	...
-	ReturnDataCopy 2854
-	DataOffset 28
-	assignment 1194
-	Number 540
-	CallValue 4258
-yul-phaser parameters:
-	--break-cost 1
-	--variable-declaration-cost 3
-	--function-call-cost 8
-	--if-cost 4
-	--expression-statement-cost 6
-	--function-definition-cost 11
-	--switch-cost 3
-	--block-cost 1
-	--leave-cost 1
-	--assignment-cost 1
-```
-

crates/explorer/src/dwarfdump.rs

@@ -1,59 +0,0 @@
-//! The `llvm-dwarfdump` utility helper library.
-
-use std::{
-    path::{Path, PathBuf},
-    process::{Command, Stdio},
-};
-
-pub static EXECUTABLE: &str = "llvm-dwarfdump";
-pub static DEBUG_LINES_ARGUMENTS: [&str; 1] = ["--debug-line"];
-pub static SOURCE_FILE_ARGUMENTS: [&str; 1] = ["--show-sources"];
-
-/// Calls the `llvm-dwarfdump` tool to extract debug line information
-/// from the shared object at `path`. Returns the output.
-///
-/// Provide `Some(dwarfdump_exectuable)` to override the default executable.
-pub fn debug_lines(
-    shared_object: &Path,
-    dwarfdump_executable: &Option<PathBuf>,
-) -> anyhow::Result<String> {
-    dwarfdump(shared_object, dwarfdump_executable, &DEBUG_LINES_ARGUMENTS)
-}
-
-/// Calls the `llvm-dwarfdump` tool to extract the source file name.
-/// Returns the source file path.
-///
-/// Provide `Some(dwarfdump_exectuable)` to override the default executable.
-pub fn source_file(
-    shared_object: &Path,
-    dwarfdump_executable: &Option<PathBuf>,
-) -> anyhow::Result<PathBuf> {
-    let output = dwarfdump(shared_object, dwarfdump_executable, &SOURCE_FILE_ARGUMENTS)?;
-    Ok(output.trim().into())
-}
-
-/// The internal `llvm-dwarfdump` helper function.
-fn dwarfdump(
-    shared_object: &Path,
-    dwarfdump_executable: &Option<PathBuf>,
-    arguments: &[&str],
-) -> anyhow::Result<String> {
-    let executable = dwarfdump_executable
-        .to_owned()
-        .unwrap_or_else(|| PathBuf::from(EXECUTABLE));
-
-    let output = Command::new(executable)
-        .args(arguments)
-        .arg(shared_object)
-        .stdin(Stdio::null())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .spawn()?
-        .wait_with_output()?;
-
-    if !output.status.success() {
-        anyhow::bail!(String::from_utf8_lossy(&output.stderr).to_string());
-    }
-
-    Ok(String::from_utf8_lossy(&output.stdout).to_string())
-}

crates/explorer/src/dwarfdump_analyzer.rs

@@ -1,250 +0,0 @@
-//! The core dwarf dump analyzer library.
-
-use std::{
-    collections::HashMap,
-    path::{Path, PathBuf},
-};
-
-use revive_yul::lexer::token::location::Location;
-
-use crate::location_mapper::{self, map_locations, LocationMap};
-
-/// Unknwon code.
-pub const OTHER: &str = "other";
-/// Compiler internal code.
-pub const INTERNAL: &str = "internal";
-/// YUL block code.
-pub const BLOCK: &str = "block";
-/// YUL function call code.
-pub const FUNCTION_CALL: &str = "function_call";
-/// YUL conditional code.
-pub const IF: &str = "if";
-/// YUL loop code.
-pub const FOR: &str = "for";
-/// YUL loop continue code.
-pub const CONTINUE: &str = "continue";
-/// YUL loop break code.
-pub const BREAK: &str = "break";
-/// YUL switch code.
-pub const SWITCH: &str = "switch";
-/// YUL variable declaration code.
-pub const DECLARATION: &str = "let";
-/// YUL variable assignment code.
-pub const ASSIGNMENT: &str = "assignment";
-/// YUL function definition code.
-pub const FUNCTION_DEFINITION: &str = "function_definition";
-/// YUL function leave code.
-pub const LEAVE: &str = "leave";
-
-/// The dwarf dump analyzer.
-///
-/// Loads debug information from `llvm-dwarfdump` and calculates statistics
-/// about the compiled YUL statements:
-/// - Statements count
-/// - Per-statement
-#[derive(Debug, Default)]
-pub struct DwarfdumpAnalyzer {
-    /// The YUL source file path.
-    source: PathBuf,
-
-    /// The YUL location to statements map.
-    location_map: LocationMap,
-
-    /// The `llvm-dwarfdump --debug-lines` output.
-    debug_lines: String,
-
-    /// The observed statements.
-    statements_count: HashMap<String, usize>,
-    /// The observed statement to instructions size.
-    statements_size: HashMap<String, u64>,
-}
-
-impl DwarfdumpAnalyzer {
-    /// The debug info analyzer constructor.
-    ///
-    /// `source` is the path to the YUL source file.
-    /// `debug_lines` is the `llvm-dwarfdump --debug-lines` output.
-    pub fn new(source: &Path, debug_lines: String) -> Self {
-        Self {
-            source: source.to_path_buf(),
-            debug_lines,
-            ..Default::default()
-        }
-    }
-
-    /// Run the analysis.
-    pub fn analyze(&mut self) -> anyhow::Result<()> {
-        self.map_locations()?;
-        self.analyze_statements()?;
-        Ok(())
-    }
-
-    /// Populate the maps so that we can always unwrap later.
-    fn map_locations(&mut self) -> anyhow::Result<()> {
-        self.location_map = map_locations(&self.source)?;
-
-        self.statements_count = HashMap::with_capacity(self.location_map.len());
-        self.statements_size = HashMap::with_capacity(self.location_map.len());
-
-        for statement in self.location_map.values() {
-            if !self.statements_size.contains_key(statement) {
-                self.statements_size.insert(statement.clone(), 0);
-            }
-
-            *self.statements_count.entry(statement.clone()).or_insert(0) += 1;
-        }
-
-        Ok(())
-    }
-
-    /// Analyze how much bytes of insturctions each statement contributes.
-    fn analyze_statements(&mut self) -> anyhow::Result<()> {
-        let mut previous_offset = 0;
-        let mut previous_location = Location::new(0, 0);
-
-        for line in self
-            .debug_lines
-            .lines()
-            .skip_while(|line| !line.starts_with("Address"))
-            .skip(2)
-        {
-            let mut parts = line.split_whitespace();
-            let (Some(offset), Some(line), Some(column)) =
-                (parts.next(), parts.next(), parts.next())
-            else {
-                continue;
-            };
-
-            let current_offset = u64::from_str_radix(offset.trim_start_matches("0x"), 16)?;
-            let mut current_location = Location::new(line.parse()?, column.parse()?);
-
-            // TODO: A bug? Needs further investigation.
-            if current_location.line == 0 && current_location.column != 0 {
-                current_location.line = previous_location.line;
-            }
-
-            if let Some(statement) = self.location_map.get(&previous_location) {
-                let contribution = current_offset - previous_offset;
-                *self.statements_size.get_mut(statement).unwrap() += contribution;
-            }
-
-            previous_offset = current_offset;
-            previous_location = current_location;
-        }
-
-        Ok(())
-    }
-
-    /// Print the per-statement count break-down.
-    pub fn display_statement_count(&self) {
-        println!("statements count:");
-        for (statement, count) in self.statements_count.iter() {
-            println!("\t{statement} {count}");
-        }
-    }
-
-    /// Print the per-statement byte size contribution break-down.
-    pub fn display_statement_size(&self) {
-        println!("bytes per statement:");
-        for (statement, size) in self.statements_size.iter() {
-            println!("\t{statement} {size}");
-        }
-    }
-
-    /// Print the estimated `yul-phaser` cost parameters.
-    pub fn display_phaser_costs(&self, yul_phaser_scale: u64) {
-        println!("yul-phaser parameters:");
-        for (parameter, cost) in self.phaser_costs(yul_phaser_scale) {
-            println!("\t{parameter} {cost}");
-        }
-    }
-
-    /// Estimate the `yul-phaser` costs using the simplified weight function:
-    /// `Total size / toal count = cost`
-    pub fn phaser_costs(&self, yul_phaser_scale: u64) -> Vec<(String, u64)> {
-        let mut costs: HashMap<String, (usize, u64)> = HashMap::with_capacity(16);
-        for (statement, count) in self
-            .statements_count
-            .iter()
-            .filter(|(_, count)| **count > 0)
-        {
-            let size = self.statements_size.get(statement).unwrap();
-            let cost = match statement.as_str() {
-                location_mapper::FOR => "--for-loop-cost",
-                location_mapper::OTHER => continue,
-                location_mapper::INTERNAL => continue,
-                location_mapper::BLOCK => "--block-cost",
-                location_mapper::FUNCTION_CALL => "--function-call-cost",
-                location_mapper::IF => "--if-cost",
-                location_mapper::CONTINUE => "--continue-cost",
-                location_mapper::BREAK => "--break-cost",
-                location_mapper::LEAVE => "--leave-cost",
-                location_mapper::SWITCH => "--switch-cost",
-                location_mapper::DECLARATION => "--variable-declaration-cost",
-                location_mapper::ASSIGNMENT => "--assignment-cost",
-                location_mapper::FUNCTION_DEFINITION => "--function-definition-cost",
-                _ => "--expression-statement-cost",
-            };
-
-            let entry = costs.entry(cost.to_string()).or_default();
-            entry.0 += count;
-            entry.1 += size;
-        }
-
-        let costs = costs
-            .iter()
-            .map(|(cost, (count, size))| {
-                let ratio = *size / *count as u64;
-                (cost.to_string(), ratio.min(100))
-            })
-            .collect::<Vec<_>>();
-
-        let scaled_costs = scale_to(
-            costs
-                .iter()
-                .map(|(_, ratio)| *ratio)
-                .collect::<Vec<_>>()
-                .as_slice(),
-            yul_phaser_scale,
-        );
-
-        costs
-            .iter()
-            .zip(scaled_costs)
-            .map(|((cost, _), scaled_ratio)| (cost.to_string(), scaled_ratio))
-            .collect()
-    }
-}
-
-/// Given a slice of u64 values, returns a Vec<u64> where each element
-/// is linearly scaled into the closed interval [1, 10].
-fn scale_to(data: &[u64], scale_max: u64) -> Vec<u64> {
-    if data.is_empty() {
-        return Vec::new();
-    }
-
-    let mut min = data[0];
-    let mut max = data[0];
-    for &x in &data[1..] {
-        if x < min {
-            min = x;
-        }
-        if x > max {
-            max = x;
-        }
-    }
-    if max < scale_max {
-        return data.to_vec();
-    }
-
-    let range = max - min;
-    data.iter()
-        .map(|&x| {
-            if range == 0 {
-                1
-            } else {
-                1 + (x - min) * scale_max / range
-            }
-        })
-        .collect()
-}

crates/explorer/src/lib.rs

@@ -1,6 +0,0 @@
-//! The revive explorer leverages debug info to get insights into emitted code.
-
-pub mod dwarfdump;
-pub mod dwarfdump_analyzer;
-pub mod location_mapper;
-pub mod yul_phaser;

crates/explorer/src/location_mapper.rs

@@ -1,158 +0,0 @@
-//! The location mapper utility maps YUL source locations to AST statements.
-//!
-//! TODO: Refactor when the AST visitor is implemented.
-
-use std::{collections::HashMap, path::Path};
-
-use revive_yul::{
-    lexer::{token::location::Location, Lexer},
-    parser::statement::{
-        block::Block,
-        expression::{function_call::name::Name, Expression},
-        object::Object,
-        Statement,
-    },
-};
-
-/// Code attributed to an unknown location.
-pub const OTHER: &str = "other";
-/// Code attributed to a compiler internal location.
-pub const INTERNAL: &str = "internal";
-/// Code attributed to a
-pub const BLOCK: &str = "block";
-pub const FUNCTION_CALL: &str = "function_call";
-pub const FOR: &str = "for";
-pub const IF: &str = "if";
-pub const CONTINUE: &str = "continue";
-pub const BREAK: &str = "break";
-pub const LEAVE: &str = "leave";
-pub const SWITCH: &str = "switch";
-pub const DECLARATION: &str = "let";
-pub const ASSIGNMENT: &str = "assignment";
-pub const FUNCTION_DEFINITION: &str = "function_definition";
-
-/// The location to statements map type alias.
-pub type LocationMap = HashMap<Location, String>;
-
-/// Construct a [LocationMap] from the given YUL `source` file.
-pub fn map_locations(source: &Path) -> anyhow::Result<LocationMap> {
-    let mut lexer = Lexer::new(std::fs::read_to_string(source)?);
-    let ast = Object::parse(&mut lexer, None).map_err(|error| {
-        anyhow::anyhow!("Contract `{}` parsing error: {:?}", source.display(), error)
-    })?;
-
-    let mut location_map = HashMap::with_capacity(1024);
-    crate::location_mapper::object_mapper(&mut location_map, &ast);
-    location_map.insert(Location::new(0, 0), OTHER.to_string());
-    location_map.insert(Location::new(1, 0), INTERNAL.to_string());
-
-    Ok(location_map)
-}
-
-/// Map the [Block].
-fn block_mapper(map: &mut LocationMap, block: &Block) {
-    map.insert(block.location, BLOCK.to_string());
-
-    for statement in &block.statements {
-        statement_mapper(map, statement);
-    }
-}
-
-/// Map the [Expression].
-fn expression_mapper(map: &mut LocationMap, expression: &Expression) {
-    if let Expression::FunctionCall(call) = expression {
-        let id = match call.name {
-            Name::UserDefined(_) => FUNCTION_CALL.to_string(),
-            _ => format!("{:?}", call.name),
-        };
-        map.insert(expression.location(), id);
-
-        for expression in &call.arguments {
-            expression_mapper(map, expression);
-        }
-    }
-}
-
-/// Map the [Statement].
-fn statement_mapper(map: &mut LocationMap, statement: &Statement) {
-    match statement {
-        Statement::Object(object) => object_mapper(map, object),
-
-        Statement::Code(code) => block_mapper(map, &code.block),
-
-        Statement::Block(block) => block_mapper(map, block),
-
-        Statement::ForLoop(for_loop) => {
-            map.insert(for_loop.location, FOR.to_string());
-
-            expression_mapper(map, &for_loop.condition);
-            block_mapper(map, &for_loop.body);
-            block_mapper(map, &for_loop.initializer);
-            block_mapper(map, &for_loop.finalizer);
-        }
-
-        Statement::IfConditional(if_conditional) => {
-            map.insert(if_conditional.location, IF.to_string());
-
-            expression_mapper(map, &if_conditional.condition);
-            block_mapper(map, &if_conditional.block);
-        }
-
-        Statement::Expression(expression) => expression_mapper(map, expression),
-
-        Statement::Continue(location) => {
-            map.insert(*location, CONTINUE.to_string());
-        }
-
-        Statement::Leave(location) => {
-            map.insert(*location, LEAVE.to_string());
-        }
-
-        Statement::Break(location) => {
-            map.insert(*location, BREAK.to_string());
-        }
-
-        Statement::Switch(switch) => {
-            map.insert(switch.expression.location(), SWITCH.to_string());
-
-            expression_mapper(map, &switch.expression);
-            for case in &switch.cases {
-                block_mapper(map, &case.block);
-            }
-            if let Some(block) = switch.default.as_ref() {
-                block_mapper(map, block);
-            }
-        }
-
-        Statement::Assignment(assignment) => {
-            map.insert(assignment.location, ASSIGNMENT.to_string());
-
-            expression_mapper(map, &assignment.initializer);
-        }
-
-        Statement::VariableDeclaration(declaration) => {
-            map.insert(declaration.location, DECLARATION.to_string());
-
-            if let Some(expression) = declaration.expression.as_ref() {
-                expression_mapper(map, expression);
-            }
-        }
-
-        Statement::FunctionDefinition(definition) => {
-            map.insert(definition.location, FUNCTION_DEFINITION.to_string());
-
-            block_mapper(map, &definition.body);
-        }
-    }
-}
-
-/// Map the [Object].
-fn object_mapper(map: &mut LocationMap, object: &Object) {
-    map.insert(object.location, object.identifier.clone());
-
-    block_mapper(map, &object.code.block);
-
-    if let Some(object) = object.inner_object.as_ref() {
-        object_mapper(map, object);
-    }
-}

crates/explorer/src/main.rs

@@ -1,56 +0,0 @@
-use std::path::PathBuf;
-
-use clap::Parser;
-
-use revive_explorer::{dwarfdump, dwarfdump_analyzer::DwarfdumpAnalyzer, yul_phaser};
-
-/// The `revive-explorer` is a helper utility for exploring the compilers YUL lowering unit.
-///
-/// It analyzes a given shared objects from the debug dump and outputs:
-/// - The count of each YUL statement translated.
-/// - A per YUL statement break-down of bytecode size contributed per.
-/// - Estimated `yul-phaser` cost parameters.
-#[derive(Parser, Debug)]
-#[command(version, about, long_about = None)]
-struct Args {
-    /// Path of the dwarfdump executable.
-    #[arg(short, long)]
-    dwarfdump: Option<PathBuf>,
-
-    /// The YUL phaser cost scale maximum value.
-    #[arg(short, long, default_value_t = 10)]
-    cost_scale: u64,
-
-    /// Run the provided yul-phaser executable using the estimated costs.
-    #[arg(short, long)]
-    yul_phaser: Option<PathBuf>,
-
-    /// Path of the shared object to analyze.
-    file: PathBuf,
-}
-
-fn main() -> anyhow::Result<()> {
-    let args = Args::parse();
-
-    let source_file = dwarfdump::source_file(&args.file, &args.dwarfdump)?;
-    let debug_lines = dwarfdump::debug_lines(&args.file, &args.dwarfdump)?;
-    let mut analyzer = DwarfdumpAnalyzer::new(source_file.as_path(), debug_lines);
-
-    analyzer.analyze()?;
-
-    if let Some(path) = args.yul_phaser.as_ref() {
-        yul_phaser::run(
-            path,
-            source_file.as_path(),
-            analyzer.phaser_costs(args.cost_scale).as_slice(),
-            num_cpus::get() / 2, // TODO: should be configurable.
-        )?;
-        return Ok(());
-    }
-
-    analyzer.display_statement_count();
-    analyzer.display_statement_size();
-    analyzer.display_phaser_costs(args.cost_scale);
-
-    Ok(())
-}

crates/explorer/src/yul_phaser.rs

@@ -1,79 +0,0 @@
-//! The revive explorer YUL phaser utility library.
-//!
-//! This can be used to invoke the `yul-phaser` utility,
-//! used to find better YUL optimizer sequences.
-
-use std::{
-    path::{Path, PathBuf},
-    process::{Command, Stdio},
-    thread,
-    time::{SystemTime, UNIX_EPOCH},
-};
-
-/// The `yul-phaser` sane default arguments:
-/// - Less verbose output.
-/// - Sufficient rounds.
-/// - Sufficient random population start.
-const ARGUMENTS: [&str; 6] = [
-    "--hide-round",
-    "--rounds",
-    "1000",
-    "--random-population",
-    "100",
-    "--show-only-top-chromosome",
-];
-
-/// Run multiple YUL phaser executables in parallel.
-pub fn run(
-    executable: &Path,
-    source: &Path,
-    costs: &[(String, u64)],
-    n_threads: usize,
-) -> anyhow::Result<()> {
-    let mut handles = Vec::with_capacity(n_threads);
-
-    for n in 0..n_threads {
-        let executable = executable.to_path_buf();
-        let source = source.to_path_buf();
-        let costs = costs.to_vec();
-
-        handles.push(thread::spawn(move || {
-            spawn_process(executable, source, costs, n)
-        }));
-    }
-
-    for handle in handles {
-        let _ = handle.join();
-    }
-
-    Ok(())
-}
-
-/// The `yul-phaser` process spawning helper function.
-fn spawn_process(
-    executable: PathBuf,
-    source: PathBuf,
-    costs: Vec<(String, u64)>,
-    seed: usize,
-) -> anyhow::Result<()> {
-    let cost_parameters = costs
-        .iter()
-        .flat_map(|(parameter, cost)| vec![parameter.clone(), cost.to_string()]);
-
-    let secs = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("Time went backwards")
-        .as_secs();
-
-    Command::new(executable)
-        .args(cost_parameters)
-        .args(ARGUMENTS)
-        .arg("--seed")
-        .arg((seed + secs as usize).to_string())
-        .arg(source)
-        .stdin(Stdio::null())
-        .spawn()?
-        .wait()?;
-
-    Ok(())
-}

crates/integration/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "revive-integration"
-version = "0.1.1"
-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 }
-
-resolc = { workspace = true }
-revive-runner = { workspace = true }
-revive-llvm-context = { workspace = true }
-
-[dev-dependencies]
-sha1 = { workspace = true }
-serde = { workspace = true }
-serde_json = { workspace = true }
-rayon = { workspace = true }

crates/integration/codesize.json

@@ -1,10 +0,0 @@
-{
-  "Baseline": 960,
-  "Computation": 2367,
-  "DivisionArithmetics": 9108,
-  "ERC20": 17655,
-  "Events": 1680,
-  "FibonacciIterative": 1536,
-  "Flipper": 2137,
-  "SHA1": 8299
-}

crates/integration/contracts/AddressPredictor.sol

@@ -1,33 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.28;
-
-contract Predicted {
-    uint public salt;
-
-    constructor(uint _salt) {
-        salt = _salt;
-    }
-}
-
-contract AddressPredictor {
-    constructor(uint _salt, bytes memory _bytecode) payable {
-        address deployed = address(new Predicted{salt: bytes32(_salt)}(_salt));
-        address predicted = predictAddress(_salt, _bytecode);
-        assert(deployed == predicted);
-    }
-
-    function predictAddress(
-        uint _foo,
-        bytes memory _bytecode
-    ) public view returns (address predicted) {
-        bytes32 addr = keccak256(
-            abi.encodePacked(
-                bytes1(0xff),
-                address(this),
-                bytes32(_foo),
-                keccak256(abi.encodePacked(_bytecode, abi.encode(_foo)))
-            )
-        );
-        predicted = address(uint160(uint(addr)));
-    }
-}

crates/integration/contracts/Balance.sol

@@ -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));
-    }
-}

crates/integration/contracts/BaseFee.sol

@@ -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);
-    }
-}

crates/integration/contracts/Baseline.sol

@@ -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 {}
-}

crates/integration/contracts/Bitwise.sol

@@ -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)
-        }
-    }
-}

crates/integration/contracts/Block.sol

@@ -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;
-        }
-    }
-}

crates/integration/contracts/BlockHash.sol

@@ -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
-        );
-    }
-}

crates/integration/contracts/Call.sol

@@ -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);
-    }
-}

crates/integration/contracts/Coinbase.sol

@@ -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);
-    }
-}

crates/integration/contracts/Computation.sol

@@ -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;
-        }
-    }
-}

crates/integration/contracts/Context.sol

@@ -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;
-    }
-}

crates/integration/contracts/Create.sol

@@ -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"}();
-    }
-}

crates/integration/contracts/Create2.sol

@@ -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");
-    }
-}

crates/integration/contracts/Crypto.sol

@@ -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);
-    }
-}

crates/integration/contracts/Delegate.sol

@@ -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);
-    }
-}

crates/integration/contracts/DelegateCaller.sol

@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.28;
-
-/* runner.json
-{
-    "differential": true,
-    "actions": [
-        {
-            "Instantiate": {
-                "code": {
-                    "Solidity": {
-                        "contract": "DelegateCaller"
-                    }
-                }
-            }
-        },
-        {
-            "Call": {
-                "dest": {
-                    "Instantiated": 0
-                },
-                "data": "e466c6c9"
-            }
-        }
-    ]
-}
-*/
-
-contract DelegateCaller {
-    function delegateNoContract() external returns (bool) {
-        address testAddress = 0x0000000000000000000000000000000000000000;
-        (bool success, ) = testAddress.delegatecall(
-            abi.encodeWithSignature("test()")
-        );
-        return success;
-    }
-}

crates/integration/contracts/DivisionArithmetics.sol

@@ -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)
-        }
-    }
-}

crates/integration/contracts/ERC20.sol

@@ -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);
-    }
-}

crates/integration/contracts/Events.sol

@@ -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);
-        }
-    }
-}

crates/integration/contracts/ExtCode.sol

@@ -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())
-        }
-    }
-}

crates/integration/contracts/Fibonacci.sol

@@ -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;
-    }
-}

crates/integration/contracts/FunctionPointer.sol

@@ -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;
-    }
-}

crates/integration/contracts/FunctionType.sol

@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.28;
-
-/* runner.json
-{
-    "differential": true,
-    "actions": [
-        {
-            "Instantiate": {
-                "code": {
-                    "Solidity": {
-                        "contract": "FunctionType"
-                    }
-                }
-            }
-        },
-        {
-            "Call": {
-                "dest": {
-                    "Instantiated": 0
-                },
-                "data": "b8c9d365"
-            }
-        }
-    ]
-}
-*/
-
-contract FunctionType {
-    uint public immutable x = 42;
-
-    function h() public view returns (function() external view returns (uint)) {
-        return this.x;
-    }
-}

crates/integration/contracts/GasLeft.sol

@@ -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);
-    }
-}

crates/integration/contracts/GasLimit.sol

@@ -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);
-    }
-}

crates/integration/contracts/GasPrice.sol

@@ -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);
-    }
-}

crates/integration/contracts/Immutables.sol

@@ -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);
-    }
-}

crates/integration/contracts/LayoutAt.sol

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.29;
-
-/* runner.json
-{
-    "differential": true,
-    "actions": [
-        {
-            "Instantiate": {
-                "code": {
-                    "Solidity": {
-                        "contract": "LayoutAt"
-                    }
-                }
-            }
-        },
-        {
-            "Call": {
-                "dest": {
-                    "Instantiated": 0
-                },
-                "data": "a7a0d537"
-            }
-        },
-        {
-            "Call": {
-                "dest": {
-                    "Instantiated": 0
-                },
-                "data": "15393349"
-            }
-        }
-    ]
-}
-*/
-
-contract LayoutAt layout at 0xDEADBEEF + 0xCAFEBABE {
-    uint[3] public something;
-
-    constructor() payable {
-        something[0] = 1337;
-        something[1] = 42;
-        something[2] = 69;
-    }
-
-    function slotOfSomething() public pure returns (uint ret) {
-        assembly {
-            ret := something.slot
-        }
-    }
-}

crates/integration/contracts/MCopy.sol

@@ -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;
-    }
-}

crates/integration/contracts/MCopyOverlap.sol

@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8;
-
-/* runner.json
-{
-    "differential": true,
-    "actions": [
-        {
-            "Instantiate": {
-                "code": {
-                    "Solidity": {
-                        "contract": "MCopyOverlap"
-                    }
-                }
-            }
-        },
-        {
-            "Call": {
-                "dest": {
-                    "Instantiated": 0
-                },
-                "data": "afdce848"
-            }
-        }
-    ]
-}
-*/
-
-function copy(
-    uint dstOffset,
-    uint srcOffset,
-    uint length
-) pure returns (bytes memory out) {
-    out = hex"2222222222222222333333333333333344444444444444445555555555555555"
-    hex"6666666666666666777777777777777788888888888888889999999999999999"
-    hex"aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddd";
-    assembly {
-        mcopy(
-            add(add(out, 0x20), dstOffset),
-            add(add(out, 0x20), srcOffset),
-            length
-        )
-    }
-}
-
-contract MCopyOverlap {
-    function mcopy_to_right_overlap() public pure returns (bytes memory) {
-        return copy(0x20, 0x10, 0x30);
-    }
-}

crates/integration/contracts/MLoad.sol

@@ -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)
-        }
-    }
-}

crates/integration/contracts/MSize.sol

@@ -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()
-        }
-    }
-}

crates/integration/contracts/MStore8.sol

@@ -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)
-        }
-    }
-}

crates/integration/contracts/ReturnDataOob.sol

@@ -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)
-        }
-    }
-}

crates/integration/contracts/SAR.sol

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8;
-
-/* runner.json
-{
-    "differential": true,
-    "actions": [
-        {
-            "Instantiate": {
-                "code": {
-                    "Solidity": {
-                        "contract": "SAR"
-                    }
-                }
-            }
-        }
-    ]
-}
-*/
-
-contract SAR {
-  constructor() payable {
-    assert(sar(0x03, 0x01) == 0x01);
-    assert(
-      sar(
-        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,
-        0x01
-      ) == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-    );
-    assert(
-      sar(
-        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,
-        0xff
-      ) == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-    );
-    assert(
-      sar(
-        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,
-        0x100
-      ) == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
-    );
-  }
-
-  function sar(uint256 a, uint256 b) public pure returns (uint256 c) {
-    assembly {
-      c := sar(b, a)
-    }
-  }
-}

crates/integration/contracts/SHA1.sol

@@ -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
-            )
-        }
-    }
-}

crates/integration/contracts/Send.sol

@@ -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 {}
-}