wip

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>
solc-json-interface: support for YUL optimizer details (#361 )
2026-06-14 21:31:05 +00:00 · 2025-07-15 10:15:30 +02:00 · 2025-07-14 11:25:45 +02:00 · 2025-07-08 17:17:05 +02:00 · 2025-07-07 17:46:55 +02:00 · 2025-07-04 19:56:52 +02:00
160 changed files with 3751 additions and 1265 deletions
@@ -3,7 +3,7 @@ inputs:
  version:
    description: ""
    required: false
-    default: "3.1.64"
+    default: "4.0.9"


 runs:
@@ -1,3 +1,13 @@
+#!/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
@@ -0,0 +1,155 @@
+#!/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()
@@ -94,7 +94,7 @@ jobs:

      - name: Install LLVM Builder
        run: |
-          cargo install --path crates/llvm-builder
+          cargo install --locked --force --path crates/llvm-builder

      - name: Clone LLVM
        run: |
@@ -0,0 +1,385 @@
+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"
@@ -14,6 +14,7 @@ concurrency:

 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:
@@ -44,7 +45,7 @@ jobs:
              exit 0
            fi

-          export PKG_VER=v$(cat Cargo.toml | grep -A 5 package] | grep version | cut -d '=' -f 2 | tr -d '"' | tr -d " ")
+          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"
          #
@@ -143,7 +144,7 @@ jobs:
    runs-on: ubuntu-24.04
    needs: [check-version-changed]
    env:
-      RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive-workflow-test/releases/download/${{ github.ref_name }}/resolc.wasm
+      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
@@ -6,6 +6,48 @@ 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.
+- Support for the YUL optimizer details in the standard json input definition.
+
+### 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.
@@ -19,6 +61,7 @@ Supported `polkadot-sdk` rev: `2503.0.1`
 ### Changed

 - Supported `polkadot-sdk` version is now `2503.0.1`
+- The `emsdk` version is now `4.0.9`

 ### Fixed

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]

 [workspace.package]
-version = "0.1.0-dev.16"
+version = "0.1.0"
 authors = [
    "Cyrill Leutwiler <cyrill@parity.io>",
    "Parity Technologies <admin@parity.io>",
@@ -14,56 +14,57 @@ repository = "https://github.com/paritytech/revive"
 rust-version = "1.85.0"

 [workspace.dependencies]
-revive-benchmarks = { version = "0.1.0-dev.16", path = "crates/benchmarks" }
-revive-builtins = { version = "0.1.0-dev.16", path = "crates/builtins" }
-revive-common = { version = "0.1.0-dev.16", path = "crates/common" }
-revive-differential = { version = "0.1.0-dev.16", path = "crates/differential" }
-revive-integration = { version = "0.1.0-dev.16", path = "crates/integration" }
-revive-linker = { version = "0.1.0-dev.16", path = "crates/linker" }
-lld-sys = { version = "0.1.0-dev.16", path = "crates/lld-sys" }
-revive-llvm-context = { version = "0.1.0-dev.16", path = "crates/llvm-context" }
-revive-runtime-api = { version = "0.1.0-dev.16", path = "crates/runtime-api" }
-revive-runner = { version = "0.1.0-dev.16", path = "crates/runner" }
-revive-solc-json-interface = { version = "0.1.0-dev.16", path = "crates/solc-json-interface" }
-revive-solidity = { version = "0.1.0-dev.16", path = "crates/solidity" }
-revive-stdlib = { version = "0.1.0-dev.16", path = "crates/stdlib" }
-revive-build-utils = { version = "0.1.0-dev.16", path = "crates/build-utils" }
+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-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.17"
+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.10"
-once_cell = "1.20"
+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.8"
+rayon = "1.10"
 clap = { version = "4", default-features = false, features = ["derive"] }
-polkavm-common = "0.21.0"
-polkavm-linker = "0.21.0"
-polkavm-disassembler = "0.21.0"
-polkavm = "0.21.0"
-alloy-primitives = { version = "0.8.21", features = ["serde"] }
-alloy-sol-types = "0.8.21"
-alloy-genesis = "0.11.1"
-alloy-serde = "0.11.1"
-env_logger = { version = "0.11.6", default-features = false }
-serde_stacker = "0.1.11"
-criterion = { version = "0.5.1", features = ["html_reports"] }
-log = { version = "0.4.25" }
-git2 = { version = "0.20.0", default-features = false }
+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.0.35"
-fs_extra = "1.3.0"
+flate2 = "1.1"
+fs_extra = "1.3"
 num_cpus = "1"
 tar = "0.4"
 toml = "0.8"
@@ -71,7 +72,7 @@ assert_cmd = "2.0"
 assert_fs = "1.1"

 # polkadot-sdk and friends
-codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
+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" }

@@ -11,7 +11,7 @@
 	machete \
 	test \
 	test-integration \
-	test-solidity \
+	test-resolc \
 	test-workspace \
 	test-cli \
 	test-wasm \
@@ -24,24 +24,24 @@
 install: install-bin install-npm

 install-bin:
-	cargo install --locked --path crates/solidity
+	cargo install --force --locked --path crates/resolc

 install-npm:
 	npm install && npm fund

 install-wasm: install-npm
-	cargo build --target wasm32-unknown-emscripten -p revive-solidity --release --no-default-features
+	cargo build --target wasm32-unknown-emscripten -p resolc --release --no-default-features
 	npm run build:package

 install-llvm-builder:
-	cargo install --path crates/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 --path crates/runner --no-default-features --locked
+	cargo install --locked --force --path crates/runner --no-default-features

 format:
 	cargo fmt --all --check
@@ -58,8 +58,8 @@ test: format clippy machete test-cli test-workspace install-revive-runner
 test-integration: install-bin
 	cargo test --package revive-integration

-test-solidity: install
-	cargo test --package revive-solidity
+test-resolc: install
+	cargo test --package resolc

 test-workspace: install
 	cargo test --workspace --exclude revive-llvm-builder
@@ -90,6 +90,6 @@ clean:
 	cargo clean ; \
 	revive-llvm clean ; \
 	rm -rf node_modules ; \
-	rm -rf crates/solidity/src/tests/cli-tests/artifacts ; \
-	cargo uninstall revive-solidity ; \
+	rm -rf crates/resolc/src/tests/cli-tests/artifacts ; \
+	cargo uninstall resolc ; \
 	cargo uninstall revive-llvm-builder ;
@@ -14,7 +14,39 @@ This is experimental software in active development and not ready just yet for p
 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
-Please consult [the documentation](https://contracts.polkadot.io/revive_compiler/installation) for installation instructions.
+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

@@ -99,8 +131,6 @@ Ensure that your branch passes `make test` locally when submitting a pull reques
 ### Design overview
 See the [relevant section in our documentation](https://contracts.polkadot.io/revive_compiler/architecture) to learn more about how the compiler works. 

-[Frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are based of ZKSync `zksolc` (the project started as a fork of the era compiler).
-
 ### 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).
@@ -109,3 +139,8 @@ 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.
+
@@ -4,11 +4,15 @@ Prior to the first stable release we neither have formal release processes nor d

 To create a new pre-release:

-1. Create a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly.
+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 tag that has the same `-dev.X` version as in `Cargo.toml`
+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 `-dev.X` name.
+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
@@ -1,5 +1,6 @@
 [package]
 name = "revive-differential"
+description = "utilities for differential testing the revive compiler against EVM"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
@@ -1,6 +1,6 @@
 [package]
 name = "revive-integration"
-version.workspace = true
+version = "0.1.1"
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
@@ -13,7 +13,7 @@ alloy-sol-types = { workspace = true }
 hex = { workspace = true }
 serde_json = { workspace = true }

-revive-solidity = { workspace = true }
+resolc = { workspace = true }
 revive-runner = { workspace = true }
 revive-llvm-context = { workspace = true }

@@ -1,10 +1,10 @@
 {
-  "Baseline": 939,
-  "Computation": 2282,
-  "DivisionArithmetics": 8849,
-  "ERC20": 18308,
-  "Events": 1640,
-  "FibonacciIterative": 1497,
+  "Baseline": 945,
+  "Computation": 2308,
+  "DivisionArithmetics": 2334,
+  "ERC20": 21363,
+  "Events": 1677,
+  "FibonacciIterative": 1516,
  "Flipper": 2099,
-  "SHA1": 8243
+  "SHA1": 8268
 }
@@ -0,0 +1,49 @@
+// 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)
+    }
+  }
+}
@@ -1,8 +1,8 @@
 use alloy_primitives::{Address, Bytes, I256, U256};
 use alloy_sol_types::{sol, SolCall, SolConstructor};

+use resolc::test_utils::*;
 use revive_llvm_context::OptimizerSettings;
-use revive_solidity::test_utils::*;

 #[derive(Clone)]
 pub struct Contract {
@@ -60,6 +60,7 @@ test_spec!(mload, "MLoad", "MLoad.sol");
 test_spec!(delegate_no_contract, "DelegateCaller", "DelegateCaller.sol");
 test_spec!(function_type, "FunctionType", "FunctionType.sol");
 test_spec!(layout_at, "LayoutAt", "LayoutAt.sol");
+test_spec!(shift_arithmetic_right, "SAR", "SAR.sol");

 fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
    vec![Instantiate {
@@ -6,7 +6,7 @@ authors = [
    "Anton Baliasnikov <aba@matterlabs.dev>",
    "Cyrill Leutwiler <cyrill@parity.io>",
 ]
-version.workspace = true
+version = "0.2.0"
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
@@ -22,7 +22,7 @@ impl std::str::FromStr for BuildType {
            "Release" => Ok(Self::Release),
            "RelWithDebInfo" => Ok(Self::RelWithDebInfo),
            "MinSizeRel" => Ok(Self::MinSizeRel),
-            value => Err(format!("Unsupported build type: `{}`", value)),
+            value => Err(format!("Unsupported build type: `{value}`")),
        }
    }
 }
@@ -16,7 +16,7 @@ impl std::str::FromStr for CcacheVariant {
        match value {
            "ccache" => Ok(Self::Ccache),
            "sccache" => Ok(Self::Sccache),
-            value => Err(format!("Unsupported ccache variant: `{}`", value)),
+            value => Err(format!("Unsupported ccache variant: `{value}`")),
        }
    }
 }
@@ -127,23 +127,22 @@ pub fn build(
    sanitizer: Option<sanitizer::Sanitizer>,
    enable_valgrind: bool,
 ) -> anyhow::Result<()> {
-    log::trace!("build type: {:?}", build_type);
-    log::trace!("target env: {:?}", target_env);
-    log::trace!("targets: {:?}", targets);
-    log::trace!("llvm projects: {:?}", llvm_projects);
-    log::trace!("enable rtti: {:?}", enable_rtti);
-    log::trace!("default target: {:?}", default_target);
-    log::trace!("eneable tests: {:?}", enable_tests);
-    log::trace!("enable_coverage: {:?}", enable_coverage);
-    log::trace!("extra args: {:?}", extra_args);
-    log::trace!("sanitzer: {:?}", sanitizer);
-    log::trace!("enable valgrind: {:?}", enable_valgrind);
+    log::trace!("build type: {build_type:?}");
+    log::trace!("target env: {target_env:?}");
+    log::trace!("targets: {targets:?}");
+    log::trace!("llvm projects: {llvm_projects:?}");
+    log::trace!("enable rtti: {enable_rtti:?}");
+    log::trace!("default target: {default_target:?}");
+    log::trace!("eneable tests: {enable_tests:?}");
+    log::trace!("enable_coverage: {enable_coverage:?}");
+    log::trace!("extra args: {extra_args:?}");
+    log::trace!("sanitzer: {sanitizer:?}");
+    log::trace!("enable valgrind: {enable_valgrind:?}");

    if !PathBuf::from(LLVMPath::DIRECTORY_LLVM_SOURCE).exists() {
        log::error!(
-            "LLVM project source directory {} does not exist (run `revive-llvm --target-env {} clone`)",
-            LLVMPath::DIRECTORY_LLVM_SOURCE,
-            target_env
+            "LLVM project source directory {} does not exist (run `revive-llvm --target-env {target_env} clone`)",
+            LLVMPath::DIRECTORY_LLVM_SOURCE
        )
    }

@@ -22,7 +22,7 @@ impl std::str::FromStr for LLVMProject {
            "lld" => Ok(Self::LLD),
            "lldb" => Ok(Self::LLDB),
            "mlir" => Ok(Self::MLIR),
-            value => Err(format!("Unsupported LLVM project to enable: `{}`", value)),
+            value => Err(format!("Unsupported LLVM project to enable: `{value}`")),
        }
    }
 }
@@ -30,7 +30,7 @@ impl TryFrom<&PathBuf> for Lock {
    fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
        let mut config_str = String::new();
        let mut config_file =
-            File::open(path).with_context(|| format!("Error opening {:?} file", path))?;
+            File::open(path).with_context(|| format!("Error opening {path:?} file"))?;
        config_file.read_to_string(&mut config_str)?;
        Ok(toml::from_str(&config_str)?)
    }
@@ -29,7 +29,7 @@ impl FromStr for Platform {
    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value {
            "PolkaVM" => Ok(Self::PolkaVM),
-            value => Err(format!("Unsupported platform: `{}`", value)),
+            value => Err(format!("Unsupported platform: `{value}`")),
        }
    }
 }
@@ -69,8 +69,8 @@ fn main_inner() -> anyhow::Result<()> {
                })
                .collect();

-            log::debug!("extra_args: {:#?}", extra_args);
-            log::debug!("extra_args_unescaped: {:#?}", extra_args_unescaped);
+            log::debug!("extra_args: {extra_args:#?}");
+            log::debug!("extra_args_unescaped: {extra_args_unescaped:#?}");

            if let Some(ccache_variant) = ccache_variant {
                revive_llvm_builder::utils::check_presence(ccache_variant.to_string().as_str())?;
@@ -30,7 +30,7 @@ impl std::str::FromStr for Sanitizer {
            "thread" => Ok(Self::Thread),
            "dataflow" => Ok(Self::DataFlow),
            "address;undefined" => Ok(Self::AddressUndefined),
-            value => Err(format!("Unsupported sanitizer: `{}`", value)),
+            value => Err(format!("Unsupported sanitizer: `{value}`")),
        }
    }
 }
@@ -20,7 +20,7 @@ impl std::str::FromStr for TargetEnv {
            "gnu" => Ok(Self::GNU),
            "musl" => Ok(Self::MUSL),
            "emscripten" => Ok(Self::Emscripten),
-            value => Err(format!("Unsupported target environment: `{}`", value)),
+            value => Err(format!("Unsupported target environment: `{value}`")),
        }
    }
 }
@@ -15,7 +15,7 @@ impl std::str::FromStr for TargetTriple {
    fn from_str(value: &str) -> Result<Self, Self::Err> {
        match value {
            "polkavm" => Ok(Self::PolkaVM),
-            value => Err(format!("Unsupported target triple: `{}`", value)),
+            value => Err(format!("Unsupported target triple: `{value}`")),
        }
    }
 }
@@ -38,7 +38,7 @@ pub const MUSL_SNAPSHOTS_URL: &str = "https://git.musl-libc.org/cgit/musl/snapsh
 pub const EMSDK_SOURCE_URL: &str = "https://github.com/emscripten-core/emsdk.git";

 /// The emscripten SDK version.
-pub const EMSDK_VERSION: &str = "3.1.64";
+pub const EMSDK_VERSION: &str = "4.0.9";

 /// The subprocess runner.
 ///
@@ -92,7 +92,7 @@ pub fn unpack_tar(filename: PathBuf, path: &str) -> anyhow::Result<()> {
 pub fn download_musl(name: &str) -> anyhow::Result<()> {
    log::info!("downloading musl {name}");
    let tar_file_name = format!("{name}.tar.gz");
-    let url = format!("{}/{tar_file_name}", MUSL_SNAPSHOTS_URL);
+    let url = format!("{MUSL_SNAPSHOTS_URL}/{tar_file_name}");
    let target_path = crate::llvm_path::DIRECTORY_LLVM_TARGET
        .get()
        .unwrap()
@@ -223,6 +223,6 @@ pub fn install_emsdk() -> anyhow::Result<()> {
 /// The LLVM target directory default path.
 pub fn directory_target_llvm(target_env: crate::target_env::TargetEnv) -> PathBuf {
    crate::llvm_path::DIRECTORY_LLVM_TARGET
-        .get_or_init(|| PathBuf::from(format!("./target-llvm/{}/", target_env)))
+        .get_or_init(|| PathBuf::from(format!("./target-llvm/{target_env}/")))
        .clone()
 }
@@ -1,6 +1,6 @@
 [package]
 name = "revive-llvm-context"
-version.workspace = true
+version = "0.3.0"
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
@@ -2,6 +2,7 @@

 pub mod ir_type;

+use std::path::Path;
 use std::path::PathBuf;

 use serde::Deserialize;
@@ -16,6 +17,14 @@ pub struct DebugConfig {
    pub output_directory: Option<PathBuf>,
    /// Whether debug info should be emitted.
    pub emit_debug_info: bool,
+    /// The YUL debug output file path.
+    ///
+    /// Is expected to be configured when running in YUL mode.
+    pub contract_path: Option<PathBuf>,
+    /// The YUL input file path.
+    ///
+    /// Is expected to be configured when not running in YUL mode.
+    pub yul_path: Option<PathBuf>,
 }

 impl DebugConfig {
@@ -24,15 +33,41 @@ impl DebugConfig {
        Self {
            output_directory,
            emit_debug_info,
+            contract_path: None,
+            yul_path: None,
        }
    }

+    /// Set the current YUL path.
+    pub fn set_yul_path(&mut self, yul_path: &Path) {
+        self.yul_path = yul_path.to_path_buf().into();
+    }
+
+    /// Set the current contract path.
+    pub fn set_contract_path(&mut self, contract_path: &str) {
+        self.contract_path = self.yul_source_path(contract_path);
+    }
+
+    /// Returns with the following precedence:
+    /// 1. The YUL source path if it was configured.
+    /// 2. The source YUL path from the debug output dir if it was configured.
+    /// 3. `None` if there is no debug output directory.
+    pub fn yul_source_path(&self, contract_path: &str) -> Option<PathBuf> {
+        if let Some(path) = self.yul_path.as_ref() {
+            return Some(path.clone());
+        }
+
+        self.output_directory.as_ref().map(|output_directory| {
+            let mut file_path = output_directory.to_owned();
+            let full_file_name = Self::full_file_name(contract_path, None, IRType::Yul);
+            file_path.push(full_file_name);
+            file_path
+        })
+    }
+
    /// Dumps the Yul IR.
    pub fn dump_yul(&self, contract_path: &str, code: &str) -> anyhow::Result<()> {
-        if let Some(output_directory) = self.output_directory.as_ref() {
-            let mut file_path = output_directory.to_owned();
-            let full_file_name = Self::full_file_name(contract_path, None, IRType::Yul);
-            file_path.push(full_file_name);
+        if let Some(file_path) = self.yul_source_path(contract_path) {
            std::fs::write(file_path, code)?;
        }

@@ -51,11 +51,20 @@ pub struct DebugInfo<'ctx> {

 impl<'ctx> DebugInfo<'ctx> {
    /// A shortcut constructor.
-    pub fn new(module: &inkwell::module::Module<'ctx>) -> Self {
+    pub fn new(
+        module: &inkwell::module::Module<'ctx>,
+        debug_config: &crate::debug_config::DebugConfig,
+    ) -> Self {
+        let module_name = module.get_name().to_string_lossy();
+        let yul_name = debug_config
+            .contract_path
+            .as_ref()
+            .map(|path| path.display().to_string());
+
        let (builder, compile_unit) = module.create_debug_info_builder(
            true,
            inkwell::debug_info::DWARFSourceLanguage::C,
-            module.get_name().to_string_lossy().as_ref(),
+            yul_name.as_deref().unwrap_or_else(|| module_name.as_ref()),
            "",
            "",
            false,
@@ -15,6 +15,8 @@ use crate::optimizer::settings::size_level::SizeLevel;
 use crate::optimizer::Optimizer;
 use crate::polkavm::context::attribute::Attribute;
 use crate::polkavm::context::pointer::Pointer;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;

 use self::declaration::Declaration;
 use self::r#return::Return;
@@ -28,7 +30,9 @@ pub struct Function<'ctx> {
    /// The LLVM function declaration.
    declaration: Declaration<'ctx>,
    /// The stack representation.
-    stack: HashMap<String, Pointer<'ctx>>,
+    stack: HashMap<String, u64>,
+    /// The stack variables pointer.
+    stack_variables: Pointer<'ctx>,
    /// The return value entity.
    r#return: Return<'ctx>,

@@ -56,11 +60,14 @@ impl<'ctx> Function<'ctx> {

        entry_block: inkwell::basic_block::BasicBlock<'ctx>,
        return_block: inkwell::basic_block::BasicBlock<'ctx>,
+
+        stack_variables: Pointer<'ctx>,
    ) -> Self {
        Self {
            name,
            declaration,
            stack: HashMap::with_capacity(Self::STACK_HASHMAP_INITIAL_CAPACITY),
+            stack_variables,
            r#return,

            entry_block,
@@ -210,22 +217,49 @@ impl<'ctx> Function<'ctx> {

    /// Saves the pointer to a stack variable, returning the pointer to the shadowed variable,
    /// if it exists.
-    pub fn insert_stack_pointer(
+    pub fn insert_stack_pointer<D: Dependency + Clone>(
        &mut self,
+        context: &mut Context<'ctx, D>,
        name: String,
-        pointer: Pointer<'ctx>,
-    ) -> Option<Pointer<'ctx>> {
-        self.stack.insert(name, pointer)
+    ) -> Pointer<'ctx> {
+        let pointer_name = format!("{}_stack_pointer", &name);
+        let len = self.stack.len();
+        let index = *self.stack.entry(name).or_insert_with(|| len as u64);
+        let indices = &[
+            context.xlen_type().const_zero(),
+            context.xlen_type().const_int(index, false),
+        ];
+
+        context.build_gep(
+            self.stack_variables,
+            indices,
+            context.word_type(),
+            &pointer_name,
+        )
    }

    /// Gets the pointer to a stack variable.
-    pub fn get_stack_pointer(&self, name: &str) -> Option<Pointer<'ctx>> {
-        self.stack.get(name).copied()
-    }
+    pub fn get_stack_pointer<D: Dependency + Clone>(
+        &self,
+        context: &mut Context<'ctx, D>,
+        name: String,
+    ) -> Pointer<'ctx> {
+        let pointer_name = format!("{}_stack_pointer", &name);
+        let index = *self
+            .stack
+            .get(&name)
+            .unwrap_or_else(|| panic!("stack pointer access prior to insertion: {name}"));
+        let indices = &[
+            context.xlen_type().const_zero(),
+            context.xlen_type().const_int(index, false),
+        ];

-    /// Removes the pointer to a stack variable.
-    pub fn remove_stack_pointer(&mut self, name: &str) {
-        self.stack.remove(name);
+        context.build_gep(
+            self.stack_variables,
+            indices,
+            context.word_type(),
+            &pointer_name,
+        )
    }

    /// Returns the return entity representation.
@@ -48,6 +48,7 @@ where
            function_type,
            0,
            Some(inkwell::module::Linkage::External),
+            1024,
        )?;

        self.inner.declare(context)
@@ -1,6 +1,7 @@
 //! The entry function.

 use inkwell::types::BasicType;
+use revive_solc_json_interface::PolkaVMDefaultHeapMemorySize;

 use crate::polkavm::context::address_space::AddressSpace;
 use crate::polkavm::context::function::runtime;
@@ -38,9 +39,12 @@ impl Entry {
            context.xlen_type().const_zero(),
        );

-        let heap_memory_type = context
-            .byte_type()
-            .array_type(context.memory_config.heap_size);
+        let heap_memory_type = context.byte_type().array_type(
+            context
+                .memory_config
+                .heap_size
+                .unwrap_or(PolkaVMDefaultHeapMemorySize),
+        );
        context.set_global(
            crate::polkavm::GLOBAL_HEAP_MEMORY,
            heap_memory_type,
@@ -141,6 +145,7 @@ where
            entry_function_type,
            0,
            Some(inkwell::module::Linkage::External),
+            0,
        )?;

        context.declare_global(
@@ -48,6 +48,7 @@ where
            function_type,
            0,
            Some(inkwell::module::Linkage::External),
+            1024,
        )?;

        self.inner.declare(context)
@@ -25,6 +25,8 @@ use inkwell::debug_info::AsDIScope;
 use inkwell::debug_info::DIScope;
 use inkwell::types::BasicType;
 use inkwell::values::BasicValue;
+use revive_solc_json_interface::PolkaVMDefaultHeapMemorySize;
+use revive_solc_json_interface::PolkaVMDefaultStackMemorySize;
 use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory;

 use crate::optimizer::settings::Settings as OptimizerSettings;
@@ -233,13 +235,19 @@ where
        Self::set_data_layout(llvm, &module);
        Self::link_stdlib_module(llvm, &module);
        Self::link_polkavm_imports(llvm, &module);
-        Self::set_polkavm_stack_size(llvm, &module, memory_config.stack_size);
+        Self::set_polkavm_stack_size(
+            llvm,
+            &module,
+            memory_config
+                .stack_size
+                .unwrap_or(PolkaVMDefaultStackMemorySize),
+        );
        Self::set_module_flags(llvm, &module);

        let intrinsics = Intrinsics::new(llvm, &module);
        let llvm_runtime = LLVMRuntime::new(llvm, &module, &optimizer);
        let debug_info = debug_config.emit_debug_info.then(|| {
-            let debug_info = DebugInfo::new(&module);
+            let debug_info = DebugInfo::new(&module, &debug_config);
            debug_info.initialize_module(llvm, &module);
            debug_info
        });
@@ -455,6 +463,7 @@ where
        r#type: inkwell::types::FunctionType<'ctx>,
        return_values_length: usize,
        linkage: Option<inkwell::module::Linkage>,
+        stack_variables: u32,
    ) -> anyhow::Result<Rc<RefCell<Function<'ctx>>>> {
        let value = self.module().add_function(name, r#type, linkage);

@@ -476,15 +485,30 @@ where
        let entry_block = self.llvm.append_basic_block(value, "entry");
        let return_block = self.llvm.append_basic_block(value, "return");

+        self.builder().position_at_end(entry_block);
+        let stack_variables_pointer = self.build_alloca(
+            self.word_type().array_type(stack_variables),
+            "stack_variables",
+        );
+
        let r#return = match return_values_length {
            0 => FunctionReturn::none(),
            1 => {
-                self.set_basic_block(entry_block);
-                let pointer = self.build_alloca(self.word_type(), "return_pointer");
-                FunctionReturn::primitive(pointer)
+                //self.set_basic_block(entry_block);
+                //let pointer = self
+                //    .current_function()
+                //    .borrow_mut()
+                //    .insert_stack_pointer(self, format!("{name}_return_pointer"));
+
+                FunctionReturn::primitive(self.build_gep(
+                    stack_variables_pointer,
+                    &[self.xlen_type().const_zero(), self.xlen_type().const_zero()],
+                    self.word_type(),
+                    "return_pointer",
+                ))
            }
            size => {
-                self.set_basic_block(entry_block);
+                //self.set_basic_block(entry_block);
                let pointer = self.build_alloca(
                    self.structure_type(
                        vec![self.word_type().as_basic_type_enum(); size].as_slice(),
@@ -501,6 +525,7 @@ where
            r#return,
            entry_block,
            return_block,
+            stack_variables_pointer,
        );
        Function::set_default_attributes(self.llvm, function.declaration(), &self.optimizer);
        let function = Rc::new(RefCell::new(function));
@@ -728,6 +753,23 @@ where
        pointer
    }

+    pub fn variable_decl<T: BasicType<'ctx> + Clone + Copy>(
+        &self,
+        r#type: T,
+        name: &str,
+    ) -> Pointer<'ctx> {
+        let pointer = self.builder.build_alloca(r#type, name).unwrap();
+
+        pointer
+            .as_instruction()
+            .unwrap()
+            .set_alignment(revive_common::BYTE_LENGTH_STACK_ALIGN as u32)
+            .expect("Alignment is valid");
+
+        Pointer::new(r#type, AddressSpace::Stack, pointer)
+    }
+
+    /// Truncate `address` to the ethereum address length and store it as bytes on the stack.
    /// Builds an aligned stack allocation at the current position.
    /// Use this if [`build_alloca_at_entry`] might change program semantics.
    /// Otherwise, alloca should always be built at the function prelude!
@@ -1443,7 +1485,11 @@ where
    }

    pub fn heap_size(&self) -> inkwell::values::IntValue<'ctx> {
-        self.xlen_type()
-            .const_int(self.memory_config.heap_size as u64, false)
+        self.xlen_type().const_int(
+            self.memory_config
+                .heap_size
+                .unwrap_or(PolkaVMDefaultHeapMemorySize) as u64,
+            false,
+        )
    }
 }
@@ -35,6 +35,7 @@ where
            Self::r#type(context),
            0,
            Some(inkwell::module::Linkage::External),
+            0,
        )?;

        let mut attributes = Self::ATTRIBUTES.to_vec();
@@ -40,6 +40,7 @@ pub fn check_attribute_null_pointer_is_invalid() {
                .fn_type(&[context.word_type().into()], false),
            1,
            Some(inkwell::module::Linkage::External),
+            16,
        )
        .expect("Failed to add function");
    assert!(!function
@@ -63,6 +64,7 @@ pub fn check_attribute_optimize_for_size_mode_3() {
                .fn_type(&[context.word_type().into()], false),
            1,
            Some(inkwell::module::Linkage::External),
+            16,
        )
        .expect("Failed to add function");
    assert!(!function
@@ -86,6 +88,7 @@ pub fn check_attribute_optimize_for_size_mode_z() {
                .fn_type(&[context.word_type().into()], false),
            1,
            Some(inkwell::module::Linkage::External),
+            16,
        )
        .expect("Failed to add function");
    assert!(function
@@ -109,6 +112,7 @@ pub fn check_attribute_min_size_mode_3() {
                .fn_type(&[context.word_type().into()], false),
            1,
            Some(inkwell::module::Linkage::External),
+            16,
        )
        .expect("Failed to add function");
    assert!(!function
@@ -132,6 +136,7 @@ pub fn check_attribute_min_size_mode_z() {
                .fn_type(&[context.word_type().into()], false),
            1,
            Some(inkwell::module::Linkage::External),
+            16,
        )
        .expect("Failed to add function");
    assert!(function
@@ -204,7 +204,7 @@ where
            &context.word_type().const_all_ones(),
            overflow_negative_block,
        ),
-        (&context.word_const(0), overflow_block),
+        (&context.word_const(0), overflow_positive_block),
    ]);
    Ok(result.as_basic_value())
 }
@@ -37,7 +37,7 @@ pub fn build_assembly_text(
    let mut disassembled_code = Vec::new();
    disassembler
        .disassemble_into(&mut disassembled_code)
-        .with_context(|| format!("Failed to disassemble contract: {}", contract_path))?;
+        .with_context(|| format!("Failed to disassemble contract: {contract_path}"))?;

    let assembly_text = String::from_utf8(disassembled_code).with_context(|| {
        format!("Failed to convert disassembled code to string for contract: {contract_path}")
@@ -1,6 +1,6 @@
 [package]
-name = "revive-solidity"
-version.workspace = true
+name = "resolc"
+version = "0.3.0"
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
@@ -18,29 +18,26 @@ path = "src/resolc/main.rs"
 doctest = false

 [dependencies]
-clap = { workspace = true }
-thiserror = { workspace = true }
 anyhow = { workspace = true }
-which = { workspace = true }
+clap = { workspace = true }
+hex = { workspace = true }
+inkwell = { workspace = true }
+once_cell = { workspace = true }
 path-slash = { workspace = true }
 rayon = { workspace = true, optional = true }
-
+semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-semver = { workspace = true }
-once_cell = { workspace = true }
-regex = { workspace = true }
-hex = { workspace = true }
-num = { workspace = true }
 sha3 = { workspace = true }
-inkwell = { workspace = true }
+which = { workspace = true }

 revive-common = { workspace = true }
 revive-llvm-context = { workspace = true }
 revive-solc-json-interface = { workspace = true, features = ["resolc"] }
+revive-yul = { workspace = true }

 [target.'cfg(target_env = "musl")'.dependencies]
-mimalloc = { version = "*", default-features = false }
+mimalloc = { version = "0.1.46", default-features = false }

 [target.'cfg(target_os = "emscripten")'.dependencies]
 libc = { workspace = true }
@@ -0,0 +1,11 @@
+fn main() {
+    match git2::Repository::open("../..") {
+        Ok(repo) => {
+            let head = repo.head().expect("should have head");
+            let commit = head.peel_to_commit().expect("should have commit");
+            let id = &commit.id().to_string()[..7];
+            println!("cargo:rustc-env=GIT_COMMIT_HASH={id}");
+        }
+        Err(_) => println!("cargo:rustc-env=GIT_COMMIT_HASH=unknown"),
+    };
+}
@@ -7,7 +7,6 @@ pub(crate) mod process;
 pub(crate) mod project;
 pub(crate) mod solc;
 pub(crate) mod version;
-pub(crate) mod yul;

 pub use self::build::contract::Contract as ContractBuild;
 pub use self::build::Build;
@@ -55,7 +54,7 @@ pub fn yul<T: Compiler>(
    solc: &mut T,
    optimizer_settings: revive_llvm_context::OptimizerSettings,
    include_metadata_hash: bool,
-    debug_config: revive_llvm_context::DebugConfig,
+    mut debug_config: revive_llvm_context::DebugConfig,
    llvm_arguments: &[String],
    memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 ) -> anyhow::Result<Build> {
@@ -78,6 +77,7 @@ pub fn yul<T: Compiler>(
    let solc_validator = Some(&*solc);
    let project = Project::try_from_yul_path(path, solc_validator)?;

+    debug_config.set_yul_path(path);
    let build = project.compile(
        optimizer_settings,
        include_metadata_hash,
@@ -230,7 +230,7 @@ pub fn standard_json<T: Compiler>(
        revive_llvm_context::OptimizerSettings::try_from(&solc_input.settings.optimizer)?;

    let polkavm_settings = solc_input.settings.polkavm.unwrap_or_default();
-    debug_config.emit_debug_info = polkavm_settings.debug_information;
+    debug_config.emit_debug_info = polkavm_settings.debug_information.unwrap_or_default();

    let include_metadata_hash = match solc_input.settings.metadata {
        Some(ref metadata) => metadata.bytecode_hash != Some(MetadataHash::None),
@@ -266,7 +266,9 @@ pub fn standard_json<T: Compiler>(
            include_metadata_hash,
            debug_config,
            llvm_arguments,
-            polkavm_settings.memory_config,
+            polkavm_settings
+                .memory_config
+                .unwrap_or_else(SolcStandardJsonInputSettingsPolkaVMMemory::default),
        )?;
        build.write_to_standard_json(&mut solc_output, &solc_version)?;
    }
@@ -8,7 +8,7 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;

-use crate::yul::parser::statement::object::Object;
+use revive_yul::parser::statement::object::Object;

 use self::llvm_ir::LLVMIR;
 use self::yul::Yul;
@@ -5,7 +5,7 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;

-use crate::yul::parser::statement::object::Object;
+use revive_yul::parser::statement::object::Object;

 /// The contract Yul source code.
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -77,7 +77,7 @@ impl Contract {
        project: Project,
        optimizer_settings: revive_llvm_context::OptimizerSettings,
        include_metadata_hash: bool,
-        debug_config: revive_llvm_context::DebugConfig,
+        mut debug_config: revive_llvm_context::DebugConfig,
        llvm_arguments: &[String],
        memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> anyhow::Result<ContractBuild> {
@@ -117,6 +117,7 @@ impl Contract {
            _ => llvm.create_module(self.path.as_str()),
        };

+        debug_config.set_contract_path(&self.path);
        let mut context = revive_llvm_context::PolkaVMContext::new(
            &llvm,
            module,
@@ -9,11 +9,14 @@ use std::path::Path;

 #[cfg(feature = "parallel")]
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use revive_solc_json_interface::SolcStandardJsonOutput;
 use serde::Deserialize;
 use serde::Serialize;
 use sha3::Digest;

+use revive_solc_json_interface::SolcStandardJsonOutput;
+use revive_yul::lexer::Lexer;
+use revive_yul::parser::statement::object::Object;
+
 use crate::build::contract::Contract as ContractBuild;
 use crate::build::Build;
 use crate::missing_libraries::MissingLibraries;
@@ -22,8 +25,6 @@ use crate::process::Process;
 use crate::project::contract::ir::IR;
 use crate::solc::version::Version as SolcVersion;
 use crate::solc::Compiler;
-use crate::yul::lexer::Lexer;
-use crate::yul::parser::statement::object::Object;

 use self::contract::Contract;

@@ -154,8 +155,8 @@ impl Project {
            .iter()
            .flat_map(|(file, names)| {
                names
-                    .iter()
-                    .map(|(name, _address)| format!("{file}:{name}"))
+                    .keys()
+                    .map(|name| format!("{file}:{name}"))
                    .collect::<HashSet<String>>()
            })
            .collect::<HashSet<String>>();
@@ -23,10 +23,6 @@ pub struct Arguments {
    #[arg(long = "supported-solc-versions")]
    pub supported_solc_versions: bool,

-    /// Print the licence and exit.
-    #[arg(long = "license")]
-    pub license: bool,
-
    /// Specify the input paths and remappings.
    /// If an argument contains a '=', it is considered a remapping.
    /// Multiple Solidity files can be passed in the default Solidity mode.
@@ -5,7 +5,7 @@ pub mod arguments;
 use std::io::Write;
 use std::str::FromStr;

-use revive_solidity::Process;
+use resolc::Process;

 use self::arguments::Arguments;

@@ -36,7 +36,7 @@ fn main_inner() -> anyhow::Result<()> {
            std::io::stdout(),
            "{} version {}",
            env!("CARGO_PKG_DESCRIPTION"),
-            revive_solidity::ResolcVersion::default().long
+            resolc::ResolcVersion::default().long
        )?;
        return Ok(());
    }
@@ -45,20 +45,12 @@ fn main_inner() -> anyhow::Result<()> {
        writeln!(
            std::io::stdout(),
            ">={},<={}",
-            revive_solidity::SolcFirstSupportedVersion,
-            revive_solidity::SolcLastSupportedVersion,
+            resolc::SolcFirstSupportedVersion,
+            resolc::SolcLastSupportedVersion,
        )?;
        return Ok(());
    }

-    if arguments.license {
-        let license_mit = include_str!("../../../../LICENSE-MIT");
-        let license_apache = include_str!("../../../../LICENSE-APACHE");
-
-        writeln!(std::io::stdout(), "{}\n{}\n", license_mit, license_apache)?;
-        return Ok(());
-    }
-
    #[cfg(feature = "parallel")]
    rayon::ThreadPoolBuilder::new()
        .stack_size(RAYON_WORKER_STACK_SIZE)
@@ -71,20 +63,20 @@ fn main_inner() -> anyhow::Result<()> {
            let mut infile = std::fs::File::open(fname)?;
            #[cfg(target_os = "emscripten")]
            {
-                return revive_solidity::WorkerProcess::run(Some(&mut infile));
+                return resolc::WorkerProcess::run(Some(&mut infile));
            }
            #[cfg(not(target_os = "emscripten"))]
            {
-                return revive_solidity::NativeProcess::run(Some(&mut infile));
+                return resolc::NativeProcess::run(Some(&mut infile));
            }
        }
        #[cfg(target_os = "emscripten")]
        {
-            return revive_solidity::WorkerProcess::run(None);
+            return resolc::WorkerProcess::run(None);
        }
        #[cfg(not(target_os = "emscripten"))]
        {
-            return revive_solidity::NativeProcess::run(None);
+            return resolc::NativeProcess::run(None);
        }
    }

@@ -111,14 +103,16 @@ fn main_inner() -> anyhow::Result<()> {
    let mut solc = {
        #[cfg(target_os = "emscripten")]
        {
-            revive_solidity::SoljsonCompiler
+            resolc::SoljsonCompiler
        }

        #[cfg(not(target_os = "emscripten"))]
        {
-            revive_solidity::SolcCompiler::new(arguments.solc.unwrap_or_else(|| {
-                revive_solidity::SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned()
-            }))?
+            resolc::SolcCompiler::new(
+                arguments
+                    .solc
+                    .unwrap_or_else(|| resolc::SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned()),
+            )?
        }
    };

@@ -148,17 +142,13 @@ fn main_inner() -> anyhow::Result<()> {
        None => true,
    };

-    let mut memory_config =
-        revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory::default();
-    if let Some(heap_size) = arguments.heap_size {
-        memory_config.heap_size = heap_size
-    }
-    if let Some(stack_size) = arguments.stack_size {
-        memory_config.stack_size = stack_size
-    }
+    let memory_config = revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory::new(
+        arguments.heap_size,
+        arguments.stack_size,
+    );

    let build = if arguments.yul {
-        revive_solidity::yul(
+        resolc::yul(
            input_files.as_slice(),
            &mut solc,
            optimizer_settings,
@@ -168,7 +158,7 @@ fn main_inner() -> anyhow::Result<()> {
            memory_config,
        )
    } else if arguments.llvm_ir {
-        revive_solidity::llvm_ir(
+        resolc::llvm_ir(
            input_files.as_slice(),
            optimizer_settings,
            include_metadata_hash,
@@ -177,7 +167,7 @@ fn main_inner() -> anyhow::Result<()> {
            memory_config,
        )
    } else if arguments.standard_json {
-        revive_solidity::standard_json(
+        resolc::standard_json(
            &mut solc,
            arguments.detect_missing_libraries,
            arguments.base_path,
@@ -188,7 +178,7 @@ fn main_inner() -> anyhow::Result<()> {
        )?;
        return Ok(());
    } else if let Some(format) = arguments.combined_json {
-        revive_solidity::combined_json(
+        resolc::combined_json(
            format,
            input_files.as_slice(),
            arguments.libraries,
@@ -210,7 +200,7 @@ fn main_inner() -> anyhow::Result<()> {
        )?;
        return Ok(());
    } else {
-        revive_solidity::standard_output(
+        resolc::standard_output(
            input_files.as_slice(),
            arguments.libraries,
            &mut solc,
@@ -250,9 +240,7 @@ fn main_inner() -> anyhow::Result<()> {

                writeln!(
                    std::io::stdout(),
-                    "Contract `{}` assembly:\n\n{}",
-                    path,
-                    assembly_text
+                    "Contract `{path}` assembly:\n\n{assembly_text}"
                )?;
            }
            if arguments.output_binary {
@@ -45,8 +45,6 @@ impl Compiler for SolcCompiler {
        include_paths: Vec<String>,
        allow_paths: Option<String>,
    ) -> anyhow::Result<SolcStandardJsonOutput> {
-        let version = self.version()?.validate(&include_paths)?.default;
-
        let mut command = std::process::Command::new(self.executable.as_str());
        command.stdin(std::process::Stdio::piped());
        command.stdout(std::process::Stdio::piped());
@@ -65,7 +63,7 @@ impl Compiler for SolcCompiler {
            command.arg(allow_paths);
        }

-        input.normalize(&version);
+        input.normalize();

        let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();

@@ -40,8 +40,7 @@ impl Compiler for SoljsonCompiler {
            anyhow::bail!("configuring allow paths is not supported with solJson")
        }

-        let version = self.version()?.validate(&include_paths)?.default;
-        input.normalize(&version);
+        input.normalize();

        let suppressed_warnings = input.suppressed_warnings.take().unwrap_or_default();

@@ -89,7 +89,7 @@ pub fn build_solidity_with_options(
        sources.clone(),
        libraries.clone(),
        remappings,
-        SolcStandardJsonInputSettingsSelection::new_required(),
+        SolcStandardJsonInputSettingsSelection::new_required_for_tests(),
        SolcStandardJsonInputSettingsOptimizer::new(
            solc_optimizer_enabled,
            optimizer_settings.middle_end_as_string().chars().last(),
@@ -154,7 +154,7 @@ pub fn build_solidity_with_options_evm(
        sources.clone(),
        libraries.clone(),
        remappings,
-        SolcStandardJsonInputSettingsSelection::new_required(),
+        SolcStandardJsonInputSettingsSelection::new_required_for_tests(),
        SolcStandardJsonInputSettingsOptimizer::new(
            solc_optimizer_enabled,
            None,
@@ -211,7 +211,7 @@ pub fn build_solidity_and_detect_missing_libraries(
        sources.clone(),
        libraries.clone(),
        None,
-        SolcStandardJsonInputSettingsSelection::new_required(),
+        SolcStandardJsonInputSettingsSelection::new_required_for_tests(),
        SolcStandardJsonInputSettingsOptimizer::new(true, None, &solc_version.default, false),
        None,
        None,
@@ -285,7 +285,7 @@ pub fn check_solidity_warning(
        sources.clone(),
        libraries,
        None,
-        SolcStandardJsonInputSettingsSelection::new_required(),
+        SolcStandardJsonInputSettingsSelection::new_required_for_tests(),
        SolcStandardJsonInputSettingsOptimizer::new(true, None, &solc_version.default, false),
        None,
        suppressed_warnings,
@@ -361,7 +361,7 @@ fn compile_evm(
    .expect("source should compile");
    let object = &contracts
        .get(contract_name)
-        .unwrap_or_else(|| panic!("contract '{}' didn't produce bin-runtime", contract_name));
+        .unwrap_or_else(|| panic!("contract '{contract_name}' didn't produce bin-runtime"));
    let code = if runtime {
        object.1.object.as_str()
    } else {
@@ -0,0 +1,22 @@
+object "Test" {                                                                                                                                            
+        code {                                                                                                                                                 
+        function allocate(size) -> ptr {                                                                                                                       
+            ptr := mload(0x40)                                                                                                                                 
+            if iszero(ptr) { ptr := 0x60 }                                                                                                                     
+            mstore(0x40, add(ptr, size))                                                                                                                       
+        }                                                                                                                                                      
+        let size := datasize("Test_deployed")          
+        let offset := allocate(size)                                                                                                                           
+        datacopy(offset, dataoffset("Test_deployed"), size)
+        return(offset, size)                                                                                                                                   
+    }                                                                          
+    object "Test_deployed" {                                                                                                                                   
+        code {                                                                                                                                                 
+{                                                                                                                                                              
+        let test:=0x5                                                                                                                                          
+        mstore(2,signextend(0x8,0x0))                                                                                                                          
+        mstore(8,lt(0xc,test))                                                 
+}                                                                                                                                                              
+                                                                                                                                                               
+    return(0, 65536)                                                                                                                                           
+}}}
@@ -15,6 +15,11 @@ const pathToBasicYulContract = path.join(
  'yul',
  contractYulFilename
 )
+const pathToMemsetYulContract = path.join(
+  pathToContracts,
+  'yul',
+  'memset.yul'
+)
 const pathToBasicSolContract = path.join(
  pathToContracts,
  'solidity',
@@ -42,6 +47,7 @@ export const paths = {
  pathToContracts: pathToContracts,
  pathToBasicSolContract: pathToBasicSolContract,
  pathToBasicYulContract: pathToBasicYulContract,
+  pathToMemsetYulContract: pathToMemsetYulContract,
  pathToSolBinOutputFile: pathToSolBinOutputFile,
  pathToSolAsmOutputFile: pathToSolAsmOutputFile,
 }
@@ -0,0 +1,18 @@
+import { executeCommand } from '../src/helper'
+import { paths } from '../src/entities'
+
+describe('tests for the memset builtin to be present', () => {
+  // -O3 is required to reproduce.
+  const command = `resolc ${paths.pathToMemsetYulContract} --yul -O3`
+  const result = executeCommand(command)
+
+  it('Valid command exit code = 0', () => {
+    expect(result.exitCode).toBe(0)
+  })
+
+  it('--yul output is presented', () => {
+    expect(result.output).toMatch(/(Compiler run successful)/i)
+    expect(result.output).toMatch(/(No output requested)/i)
+  })
+
+})
@@ -121,10 +121,10 @@ fn optimizer() {

    assert!(
        size_when_optimized_for_cycles < size_when_unoptimized,
-        "Expected the cycles-optimized bytecode to be smaller than the unoptimized. Optimized: {}B, Unoptimized: {}B", size_when_optimized_for_cycles, size_when_unoptimized,
+        "Expected the cycles-optimized bytecode to be smaller than the unoptimized. Optimized: {size_when_optimized_for_cycles}B, Unoptimized: {size_when_unoptimized}B",
    );
    assert!(
        size_when_optimized_for_size < size_when_unoptimized,
-        "Expected the size-optimized bytecode to be smaller than the unoptimized. Optimized: {}B, Unoptimized: {}B", size_when_optimized_for_size, size_when_unoptimized,
+        "Expected the size-optimized bytecode to be smaller than the unoptimized. Optimized: {size_when_optimized_for_size}B, Unoptimized: {size_when_unoptimized}B",
    );
 }
@@ -17,7 +17,7 @@ path = "src/main.rs"
 [features]
 std = ["polkadot-sdk/std"]
 default = ["solidity"]
-solidity = ["revive-solidity", "revive-differential", "revive-llvm-context"]
+solidity = ["resolc", "revive-differential", "revive-llvm-context"]

 [dependencies]
 env_logger = { workspace = true }
@@ -39,6 +39,6 @@ polkadot-sdk.features = [
    "pallet-timestamp"
 ]

-revive-solidity = { workspace = true, optional = true }
+resolc = { workspace = true, optional = true }
 revive-differential = { workspace = true, optional = true }
 revive-llvm-context = { workspace = true, optional = true }
@@ -44,7 +44,7 @@ pub use crate::specs::*;
 mod runtime;
 mod specs;

-#[cfg(not(feature = "revive-solidity"))]
+#[cfg(not(feature = "resolc"))]
 pub(crate) const NO_SOLIDITY_FRONTEND: &str =
    "revive-runner was built without the solidity frontend; please enable the 'solidity' feature!";

@@ -234,7 +234,7 @@ impl CallResult {

 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum Code {
-    #[cfg(feature = "revive-solidity")]
+    #[cfg(feature = "resolc")]
    /// Compile a single solidity source and use the blob of `contract`
    Solidity {
        path: Option<std::path::PathBuf>,
@@ -270,7 +270,7 @@ impl From<Code> for pallet_revive::Code {
                let Ok(source_code) = std::fs::read_to_string(&path) else {
                    panic!("Failed to reead source code from {}", path.display());
                };
-                pallet_revive::Code::Upload(revive_solidity::test_utils::compile_blob_with_options(
+                pallet_revive::Code::Upload(resolc::test_utils::compile_blob_with_options(
                    &contract,
                    &source_code,
                    solc_optimizer.unwrap_or(true),
@@ -4,12 +4,12 @@ use serde::{Deserialize, Serialize};

 use crate::*;
 use alloy_primitives::keccak256;
-#[cfg(feature = "revive-solidity")]
+#[cfg(feature = "resolc")]
 use alloy_primitives::Address;
-#[cfg(feature = "revive-solidity")]
+#[cfg(feature = "resolc")]
+use resolc::test_utils::*;
+#[cfg(feature = "resolc")]
 use revive_differential::{Evm, EvmLog};
-#[cfg(feature = "revive-solidity")]
-use revive_solidity::test_utils::*;

 const SPEC_MARKER_BEGIN: &str = "/* runner.json";
 const SPEC_MARKER_END: &str = "*/";
@@ -256,7 +256,7 @@ impl Specs {
            };

            match code {
-                #[cfg(feature = "revive-solidity")]
+                #[cfg(feature = "resolc")]
                Code::Bytes(bytes) if bytes.is_empty() => {
                    let contract_source = match std::fs::read_to_string(contract_path) {
                        Err(err) => panic!("unable to read {contract_path}: {err}"),
@@ -264,9 +264,9 @@ impl Specs {
                    };
                    *bytes = compile_blob(contract_name, &contract_source)
                }
-                #[cfg(not(feature = "revive-solidity"))]
+                #[cfg(not(feature = "resolc"))]
                Code::Bytes(_) => panic!("{NO_SOLIDITY_FRONTEND}"),
-                #[cfg(feature = "revive-solidity")]
+                #[cfg(feature = "resolc")]
                Code::Solidity { path, .. } if path.is_none() => *path = Some(contract_path.into()),
                _ => continue,
            }
@@ -1,6 +1,6 @@
 [package]
 name = "revive-runtime-api"
-version.workspace = true
+version = "0.2.0"
 license.workspace = true
 edition.workspace = true
 repository.workspace = true
@@ -37,12 +37,11 @@ fn compile(source_path: &str, bitcode_path: &str) {
            source_path,
        ])
        .output()
-        .unwrap_or_else(|error| panic!("failed to execute clang: {}", error));
+        .unwrap_or_else(|error| panic!("failed to execute clang: {error}"));

    assert!(
        output.status.success(),
-        "failed to compile the PolkaVM C API: {:?}",
-        output
+        "failed to compile the PolkaVM C API: {output:?}"
    );
 }

@@ -30,6 +30,13 @@ void * memmove(void *dst, const void *src, size_t n) {
 	return dst;
 }

+void * memset(void *b, int c, size_t len) {
+    uint8_t *dest = b;
+    uint8_t val = (uint8_t)c;
+    while (len-- > 0) *dest++ = val;
+    return b;
+}
+
 // Imports

 POLKAVM_IMPORT(void, address, uint32_t)
@@ -1,6 +1,6 @@
 [package]
 name = "revive-solc-json-interface"
-version.workspace = true
+version = "0.2.0"
 authors.workspace = true
 license.workspace = true
 edition.workspace = true
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Cyrill Leutwiler	94dda20880	wip Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-07-15 10:15:30 +02:00
xermicus	a0396dd6d0	solc-json-interface: support for YUL optimizer details (#361 ) - Add support for the YUL optimizer details in the standard json input definition. - Make optimizer settings optional. They can be omitted and solc will pick default values ([see here for reference](https://docs.soliditylang.org/en/latest/using-the-compiler.html#input-description)). For example allows to use the [`yul-phaser`](https://github.com/ethereum/solidity/blob/0917604a5ec7cff8bd40a1137f4fcb303fb90527/tools/yulPhaser/README.md?plain=1) utility. I did a single search with slightly adjusted costs (just made some educated guess) and after an hour or so this already found an optimizer sequence (`OESsShMxeoufcSTvlFxtelTfnfEvicdFxnsvopgCaIeLcnvsTtUrUgdVTUttaeUomccTTTuujsVVvVDvvueUrTjUOmjrrhuuTtj`) which shrinks the size of the `EndpointV2.sol` from LayerZero by 10%. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com> Signed-off-by: xermicus <cyrill@parity.io>	2025-07-14 11:25:45 +02:00
Alexander Samusev	141a8b752c	Make nigthly version semver compliant (#360 ) cc https://github.com/paritytech/revive/pull/357	2025-07-08 17:17:05 +02:00
Alexander Samusev	7c932f719b	Generate nightly builds and json files (#357 ) PR adds a nightly release pipeline. Since the logic for the nightly build and release differs significantly from the usual pipeline, I decided to put it in a separate file. The same applies to the Python script that generates JSON files. The nightly pipeline runs at 01:00 UTC every day, producing artefacts and retaining them for 40 days if commits are made the day before it runs. cc https://github.com/paritytech/revive/issues/355 cc https://github.com/paritytech/devops/issues/4141	2025-07-07 17:46:55 +02:00
xermicus	b238913a7d	emit YUL builtins debug line info and fix debug info source file (#358 ) This PR fixes and enhances debug info generation: 1. Adds line information for each lowered YUL builtin and the `if` statement. 2. Fixes the debug info source path to match the YUL file of the contract dumped to the `--debug-output-dir`. This improves inspection of the generated code a lot. Excerpt from `llvm-objdump -Sl /tmp/dbg/contracts_EndpointV2.sol.EndpointV2.so`: ``` ; /tmp/dbg/contracts_EndpointV2.sol.EndpointV2.yul:203 ; let _1 := memoryguard(0x80) 13c3e: 3aa5b023 sd a0, 0x3a0(a1) 13c42: 38a5bc23 sd a0, 0x398(a1) 13c46: 38a5b823 sd a0, 0x390(a1) 13c4a: 08000513 li a0, 0x80 13c4e: 38a5b423 sd a0, 0x388(a1) ; /tmp/dbg/contracts_EndpointV2.sol.EndpointV2.yul:204 ; mstore(64, _1) 13c52: 3885b503 ld a0, 0x388(a1) 13c56: 3905b603 ld a2, 0x390(a1) 13c5a: 3985b683 ld a3, 0x398(a1) 13c5e: 3a05b703 ld a4, 0x3a0(a1) 13c62: 38e5b023 sd a4, 0x380(a1) 13c66: 36d5bc23 sd a3, 0x378(a1) 13c6a: 36c5b823 sd a2, 0x370(a1) 13c6e: 36a5b423 sd a0, 0x368(a1) 13c72: 04000513 li a0, 0x40 13c76: 65d9 lui a1, 0x16 13c78: a605859b addiw a1, a1, -0x5a0 13c7c: 95a6 add a1, a1, s1 13c7e: 00000097 auipc ra, 0x0 13c82: 000080e7 jalr ra <__runtime+0x1de> 0000000000013c86 <.Lpcrel_hi27>: ; /tmp/dbg/contracts_EndpointV2.sol.EndpointV2.yul:205 ; if iszero(lt(calldatasize(), 4)) 13c86: 00000517 auipc a0, 0x0 13c8a: 00053503 ld a0, 0x0(a0) 13c8e: 4108 lw a0, 0x0(a0) 13c90: 4591 li a1, 0x4 13c92: 06b56263 bltu a0, a1, 0x13cf6 <.Lpcrel_hi27+0x70> 13c96: a009 j 0x13c98 <.Lpcrel_hi27+0x12> ``` --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-07-04 19:56:52 +02:00
xermicus	ed608699af	release resolc v0.3.0 (#354 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-06-28 12:32:48 +02:00
xermicus	75fc23c810	add the missing memset builtin (#353 ) Closes #350 - Add the missing `memset` builtin which was accidentally deleted in a previous PR. - Add a compilation test to ensure the `memset` builtin is present. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-06-28 12:01:34 +02:00
xermicus	486c9c28a1	new clippies (#352 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-06-28 11:48:24 +02:00
PG Herveou	7656c6a8b4	js: Add stats and override options (#348 ) - Add `RESOLC_BIN` env variable to force use a binary compiler instead of the wasm - Add `--diff-stats` options to print file path e.g ``` ~/github/redstone-oracles-monorepo main* ❯ npx @parity/resolc@latest --diff-stats \ --base-path . \ --include-path node_modules \ --bin packages/evm-connector/contracts/samples/SampleWithEvents.sol ┌─────────┬──────────────────────────────────────────────────────────────────────────┬───────────────────────────────┬────────────┬────────────┬───────────┐ │ (index) │ file │ contract │ polkavm │ bin │ diff │ ├─────────┼──────────────────────────────────────────────────────────────────────────┼───────────────────────────────┼────────────┼────────────┼───────────┤ │ 0 │ 'packages/evm-connector/contracts/core/CalldataExtractor.sol' │ 'CalldataExtractor' │ '4.31 kB' │ '2.53 kB' │ '70.12%' │ │ 1 │ 'packages/evm-connector/contracts/core/RedstoneConstants.sol' │ 'RedstoneConstants' │ '0.80 kB' │ '0.17 kB' │ '368.18%' │ │ 2 │ 'packages/evm-connector/contracts/core/RedstoneDefaultsLib.sol' │ 'RedstoneDefaultsLib' │ '0.90 kB' │ '0.31 kB' │ '189.06%' │ │ 3 │ 'packages/evm-connector/contracts/libs/BitmapLib.sol' │ 'BitmapLib' │ '0.90 kB' │ '0.31 kB' │ '189.06%' │ │ 4 │ 'packages/evm-connector/contracts/libs/NumericArrayLib.sol' │ 'NumericArrayLib' │ '0.90 kB' │ '0.31 kB' │ '189.06%' │ │ 5 │ 'packages/evm-connector/contracts/libs/SignatureLib.sol' │ 'SignatureLib' │ '0.90 kB' │ '0.31 kB' │ '189.06%' │ │ 6 │ 'packages/evm-connector/contracts/mocks/RedstoneConsumerNumericMock.sol' │ 'RedstoneConsumerNumericMock' │ '13.62 kB' │ '10.17 kB' │ '33.96%' │ │ 7 │ 'packages/evm-connector/contracts/samples/SampleWithEvents.sol' │ 'SampleWithEvents' │ '29.34 kB' │ '15.60 kB' │ '88.03%' │ └─────────┴──────────────────────────────────────────────────────────────────────────┴───────────────────────────────┴────────────┴────────────┴───────────┘ ```	2025-06-19 12:17:09 +02:00
xermicus	8754d802fa	llvm-context: bugfix PHI values in SAR builtin translation (#345 ) Closes #344 Signed-off-by: xermicus <cyrill@parity.io>	2025-06-14 15:12:03 +02:00
PG Herveou	63f0266fff	@parity/resolc fix sol file resolutions (#343 ) second take on #339 turns out that the resolve-pkg npm package was also failing to properly resolve package with an exports field define in the package.json. This fixes it and add a test case with such a package	2025-06-05 10:05:53 +02:00
xermicus	e94432eaa0	ci: the resolc version dictates binary releases (#341 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-06-03 15:47:33 +02:00
xermicus	1fc3aa1554	release resolc v0.2.0 (#340 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-06-03 15:36:54 +02:00
Chris	a77ab501c8	fix: exclude EVM bytecode from production solc requests (#338 ) This is to address issue #320 ## Introduced changes - Added new_required_for_tests() method that includes EVM bytecode flags - Modified new_required() to exclude evm.bytecode and evm.deployedBytecode - Updated test utilities to explicitly request EVM bytecode when needed Signed-off-by: 0xf333 <0x333@tuta.io>	2025-06-03 10:43:52 +02:00
xermicus	8a3c587bbe	solc-json-interface: do not unconditionally skip serialization of custom keys (#337 ) The data structure can be used to build the JSON input for `resolc` too. In that case serializing of provided custom options should not be dismissed. Makes the memory settings struct more modular as a drive-by. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-06-03 08:17:54 +02:00
PG Herveou	45b6a57cae	Fix npm package resolution (#339 ) Current approach fails with an 'ERR_PACKAGE_PATH_NOT_EXPORTED' error for npm package that defines an exports field in the package.json e.g: > require.resolve('@redstone-finance/evm-connector/package.json') will fail with Uncaught: Error [ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath './package.json' is not defined by "exports" in /home/pg/github/evm-test-suite/eth-rpc/node_modules/@redstone-finance/evm-connector/package.json code: 'ERR_PACKAGE_PATH_NOT_EXPORTED'	2025-06-02 14:41:06 +02:00
xermicus	8a730f42cc	update NPM package version (#336 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-28 08:15:41 +02:00
xermicus	413819facd	do not use wildcard dependency in resolc crate (#335 ) Do not use wildcard dependency in resolc crate. No sure why the publish dry-run doesn't catch this. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 14:19:24 +02:00
xermicus	fa0ad68279	make resolc crate publishable (#334 ) - Fetching the commit SHA must not panic if not executed in a git repository. - Remove the license printer. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 14:13:12 +02:00
xermicus	004c71d5d5	add description to revive-differential (#333 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 13:26:05 +02:00
xermicus	4d659ac2a6	release resolc v0.1.0 (#332 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 12:06:42 +02:00
xermicus	ed9dc60417	bump dependencies (#331 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 11:24:15 +02:00
xermicus	3b9144ef3b	add installation instructions to the readme (#330 ) Closes #294 --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 10:23:42 +02:00
xermicus	bd4e108bb0	resolc crate (#328 ) - Factor the YUL crate out of `revive-solidity`. - `revive-solidity` is in reality not a Solidity implementation but the revive solidity compiler driver (`resolc`). By renaming we not only get this straight but also a binary with the same name as the crate which should be less confusing. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 09:48:43 +02:00
xermicus	090e3ac13c	bugfix an env var in the release workflow (#329 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-27 09:29:25 +02:00
xermicus	3389865af7	solc-json-interface: make the input `Clone`able (#323 ) It helps external consumers working with the `revive-solc-json-interface` crate. Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-21 10:03:32 +02:00
xermicus	af39d506d9	update emsdk (#324 ) Update Emscripten SDK to latest version `v4.0.9`. Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-21 07:01:41 +02:00