release resolc v0.1.0 (#332 )

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>
bump dependencies (#331 )
2026-06-14 21:31:05 +00:00 · 2025-05-27 12:06:42 +02:00 · 2025-05-27 11:24:15 +02:00 · 2025-05-27 10:23:42 +02:00 · 2025-05-27 09:48:43 +02:00 · 2025-05-27 09:29:25 +02:00
197 changed files with 11720 additions and 3548 deletions
@@ -10,8 +10,8 @@ rustflags = [
    "-Clink-arg=-sWASM_ASYNC_COMPILATION=0",
    "-Clink-arg=-sDYNAMIC_EXECUTION=0",
    "-Clink-arg=-sALLOW_TABLE_GROWTH=1",
-    "-Clink-arg=--js-library=js/embed/soljson_interface.js",
-    "-Clink-arg=--pre-js=js/embed/pre.js",
+    "-Clink-arg=--js-library=js/emscripten/embed/soljson_interface.js",
+    "-Clink-arg=--pre-js=js/emscripten/embed/pre.js",
    "-Clink-arg=-sSTACK_SIZE=128kb",
    "-Clink-arg=-sNODEJS_CATCH_EXIT=0"
 ]
@@ -3,7 +3,7 @@ inputs:
  version:
    description: ""
    required: false
-    default: "3.1.64"
+    default: "4.0.9"


 runs:
@@ -19,7 +19,7 @@ runs:
      shell: bash
      run: |
        mkdir -p solc
-        curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.29/${SOLC_NAME}
+        curl -sSL --output solc/solc https://github.com/ethereum/solidity/releases/download/v0.8.30/${SOLC_NAME}

    - name: Make Solc Executable
      if: ${{ runner.os == 'Windows' }}
@@ -87,9 +87,14 @@ jobs:
        run: |
          brew install ninja

+      - name: Install Dependencies
+        if: ${{ matrix.host == 'windows' }}
+        run: |
+          choco install ninja
+
      - name: Install LLVM Builder
        run: |
-          cargo install --path crates/llvm-builder
+          cargo install --locked --force --path crates/llvm-builder

      - name: Clone LLVM
        run: |
@@ -14,7 +14,7 @@ concurrency:

 env:
  CARGO_TERM_COLOR: always
-  RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:68b86bc7cb2867259e6b233415a665ff4469c28b57763e78c3bfea1c68091561
+  RUST_MUSL_CROSS_IMAGE: messense/rust-musl-cross@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067

 jobs:
  check-version-changed:
@@ -143,7 +143,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
@@ -181,7 +181,7 @@ jobs:
      - name: Basic Sanity Check
        run: |
          mkdir -p solc
-          curl -sSLo solc/soljson.js https://github.com/ethereum/solidity/releases/download/v0.8.29/soljson.js
+          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');
@@ -286,3 +286,43 @@ jobs:
            resolc.wasm
            resolc_web.js
            checksums.txt
+
+  npm-release:
+    needs: [create-release]
+    runs-on: macos-14
+    environment: tags
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+
+      - name: Set Up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+
+      - run: npm ci -w js/resolc
+
+      - name: Build
+        run: |
+          cp -f resolc.{wasm,js} js/resolc/src/resolc
+          npm -w js/resolc run build
+
+      - name: npm pack
+        run: npm -w js/resolc pack
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: npm_package
+          path: "parity-resolc-*.tgz"
+
+      - uses: octokit/request-action@bbedc70b1981e610d89f1f8de88311a1fc02fb83
+        with:
+          route: POST /repos/paritytech/npm_publish_automation/actions/workflows/publish.yml/dispatches
+          ref: main
+          inputs: '${{ format(''{{ "artifact_name": "npm_package", "repo": "{0}", "run_id": "{1}" }}'', github.repository, github.run_id) }}'
+        env:
+          GITHUB_TOKEN: ${{ secrets.NPM_PUBLISH_AUTOMATION_TOKEN }}
@@ -86,13 +86,18 @@ jobs:
      - name: Install Node Packages
        run: npm install

-      - name: Run Playwright tests
-        run: |
-          cd js
-          npx playwright install --with-deps
-          npx playwright test
-
-      - name: Test revive
+      - name: Test emscripten
        run: |
          echo "Running tests for ${{ matrix.os }}"
          npm run test:wasm
+
+      - name: Test @parity/resolc
+        run: |
+          echo "Running tests for ${{ matrix.os }}"
+          npm run -w js/resolc test
+
+      - name: Run Playwright tests
+        run: |
+          cd js/emscripten
+          npx playwright install --with-deps
+          npx playwright test
@@ -1,4 +1,5 @@
 /target
+/js/resolc/dist
 target-llvm
 *.dot
 .vscode/
@@ -11,7 +12,6 @@ target-llvm
 node_modules
 artifacts
 tmp
-package-lock.json
 /*.html
 /build
 soljson.js
@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true
+}
@@ -4,6 +4,64 @@

 This is a development pre-release.

+Supported `polkadot-sdk` rev: `2503.0.1`
+
+## v0.1.0
+
+This is a development pre-release.
+
+Supported `polkadot-sdk` rev: `2503.0.1`
+
+### Added
+
+- Add the PolkaVM heap size, stack size and debug info CLI compiler options to the standard JSON settings. This makes the standard JSON input succint for reproducible builds.
+
+### Changed
+
+- Supported `polkadot-sdk` version is now `2503.0.1`
+- The `emsdk` version is now `4.0.9`
+
+### Fixed
+
+## v0.1.0-dev.16
+
+This is a development pre-release.
+
+Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`
+
+### Added
+
+- Move the npm package from paritytech/js-revive, into this repo. The package `@parity/resolc` will be deployed to npm for each release.
+- Support for solc v0.8.30
+
+### Changed
+
+- By default, heavy size optimizations are applied.
+
+### Fixed
+
+- @parity/resolc: The solc dependency package is constrained to the latest supported version, preventing breaking the package ever time a new solc package was released. 
+- The resolc npm package no longer ignores the optimizer settings
+
+## v0.1.0-dev.14
+
+This is a development pre-release.
+
+Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`
+
+### Added
+
+- The `revive-runner` helper utility binary which helps to run contracts locally without a blockchain node.
+- Allow configuration of the EVM heap memory size and stack size via CLI flags and JSON input settings.
+
+### Changed
+
+- The default PVM stack memory size was increased from 16kb to 32kb.
+
+### Fixed
+
+- Constructors avoid storing zero sized immutable data on exit.
+
 ## v0.1.0-dev.13

 This is a development pre-release.
@@ -11,16 +69,19 @@ This is a development pre-release.
 Supported `polkadot-sdk` rev:`c29e72a8628835e34deb6aa7db9a78a2e4eabcee`

 ### Added
+
 - Support for solc v0.8.29
 - Decouples the solc JSON-input-output type definitions from the Solidity fronted and expose them via a dedicated crate.
 - `--supported-solc-versions` for `resolc` binary to return a `semver` range of supported `solc` versions.
 - Support for passing LLVM command line options via the prcoess input or providing one or more `--llvm-arg='..'` resolc CLI flag. This allows more fine-grained control over the LLVM backend configuration.

 ### Changed
+
 - Storage keys and values are big endian. This was a pre-mature optimization because for the contract itself it this is a no-op and thus not observable. However we should consider the storage layout as part of the contract ABI. The endianness of transient storage values are still kept as-is.
 - Running `resolc` using webkit is no longer supported.

 ### Fixed
+
 - A missing byte swap for the create2 salt value.

 ## v0.1.0-dev.12
@@ -30,10 +91,12 @@ This is a development pre-release.
 Supported `polkadot-sdk` rev: `21f6f0705e53c15aa2b8a5706b208200447774a9`

 ### Added
+
 - Per file output selection for `--standard-json` mode.
 - The `ir` output selection option for `--standard-json` mode.

 ### Changed
+
 - Improved code size: Large contracts compile to smaller code blobs when enabling aggressive size optimizations (`-Oz`).

 ### Fixed
@@ -49,6 +112,7 @@ Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
 ### Changed

 ### Fixed
+
 - A bug causing incorrect loads from the emulated EVM linear memory.
 - A missing integer truncate after switching to 64bit.

@@ -59,10 +123,12 @@ This is a development pre-release.
 Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`

 ### Added
+
 - Support for the `coinbase` opcode.
 - The resolc web JS version.

 ### Changed
+
 - Missing the `--overwrite` flag emits an error instead of a warning.
 - The `resolc` executable prints the help by default.
 - Removed support for legacy EVM assembly (EVMLA) translation.
@@ -72,6 +138,7 @@ Supported `polkadot-sdk` rev: `274a781e8ca1a9432c7ec87593bd93214abbff50`
  If detected, the re-entrant call flag is not set and 0 deposit limit is endowed.

 ### Fixed
+
 - Solidity: Add the solc `--libraries` files to sources.
 - A data race in tests.
 - Fix `broken pipe` errors.
@@ -85,9 +152,11 @@ This is a development pre-release.
 ### Added

 ### Changed
+
 - Syscalls with more than 6 arguments now pack them into registers.

 ### Fixed
+
 - Remove reloading of the resolc.js file (fix issue with relative path in web worker)

 ## v0.1.0-dev.8
@@ -95,15 +164,18 @@ This is a development pre-release.
 This is a development pre-release.

 ### Added
+
 - The `revive-llvm-builder` crate with the `revive-llvm` helper utility for streamlined management of the LLVM framework dependency.
 - Initial support for running `resolc` in the browser.

 ### Changed
+
 - Suported contracts runtime is polkadot-sdk git version `d62a90c8c729acd98c7e9a5cab9803b8b211ffc5`.
 - The minimum supported Rust version is `1.81.0`.
 - Error out early instead of invoking `solc` with invalid base or include path flags.

 ### Fixed
+
 - Decouple the LLVM target dependency from the LLVM host dependency.
 - Do not error out if no files and no errors were produced. This aligns resolc closer to solc.
 - Fixes input normalization in the Wasm version.
@@ -113,17 +185,20 @@ This is a development pre-release.
 This is a development pre-release.

 ### Added
+
 - Implement the `GASPRICE` opcode.
 - Implement the `BASEFEE` opcode.
 - Implement the `GASLIMIT` opcode.

 ### Changed
+
 - The `GAS` opcode now returns the remaining `ref_time`.
 - Contracts can now be supplied call data input of arbitrary size.
- Some syscalls now return the value in a register, slightly improving  emitted contract code.
+- Some syscalls now return the value in a register, slightly improving emitted contract code.
 - Calls forward maximum weight limits instead of 0, anticipating a change in polkadot-sdk where weight limits of 0 no longer interprets as uncapped limit.

 ### Fixed
+
 - A linker bug which was preventing certain contracts from linking with the PVM linker.
 - JS: Fix encoding conversion from JS string (UTF-16) to UTF-8.
 - The git commit hash slug is always displayed in the version string.
@@ -133,6 +208,7 @@ This is a development pre-release.
 This is a development pre-release.

 # Added
+
 - Implement the `BLOCKHASH` opcode.
 - Implement delegate calls.
 - Implement the `GASPRICE` opcode. Currently hard-coded to return `1`.
@@ -140,21 +216,24 @@ This is a development pre-release.
 - Initial support for emitting debug info (opt in via the `-g` flag)

 # Changed
+
 - resolc now emits 64bit PolkaVM blobs, reducing contract code size and execution time.
 - The RISC-V bit-manipulation target feature (`zbb`) is enabled.

 # Fixed
- Compilation to Wasm (for usage in node and web browsers)

+- Compilation to Wasm (for usage in node and web browsers)

 ## v0.1.0-dev.5

 This is development pre-release.

 # Added
+
 - Implement the `CODESIZE` and `EXTCODESIZE` opcodes.

 # Changed
+
 - Include the full revive version in the contract metadata.

 # Fixed
@@ -164,9 +243,11 @@ This is development pre-release.
 This is development pre-release.

 # Added
+
 - Support the `ORIGIN` opcode.

 # Changed
+
 - Update polkavm to `v0.14.0`.
 - Enable the `a`, `fast-unaligned-access` and `xtheadcondmov` LLVM target features, decreasing the code size for some contracts.

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

 [workspace.package]
-version = "0.1.0-dev.13"
+version = "0.1.0"
 authors = [
    "Cyrill Leutwiler <cyrill@parity.io>",
    "Parity Technologies <admin@parity.io>",
@@ -11,59 +11,60 @@ authors = [
 license = "MIT/Apache-2.0"
 edition = "2021"
 repository = "https://github.com/paritytech/revive"
-rust-version = "1.81.0"
+rust-version = "1.85.0"

 [workspace.dependencies]
-revive-benchmarks = { version = "0.1.0-dev.13", path = "crates/benchmarks" }
-revive-builtins = { version = "0.1.0-dev.13", path = "crates/builtins" }
-revive-common = { version = "0.1.0-dev.13", path = "crates/common" }
-revive-differential = { version = "0.1.0-dev.13", path = "crates/differential" }
-revive-integration = { version = "0.1.0-dev.13", path = "crates/integration" }
-revive-linker = { version = "0.1.0-dev.13", path = "crates/linker" }
-lld-sys = { version = "0.1.0-dev.13", path = "crates/lld-sys" }
-revive-llvm-context = { version = "0.1.0-dev.13", path = "crates/llvm-context" }
-revive-runtime-api = { version = "0.1.0-dev.13", path = "crates/runtime-api" }
-revive-runner = { version = "0.1.0-dev.13", path = "crates/runner" }
-revive-solc-json-interface = { version = "0.1.0-dev.13", path = "crates/solc-json-interface" }
-revive-solidity = { version = "0.1.0-dev.13", path = "crates/solidity" }
-revive-stdlib = { version = "0.1.0-dev.13", path = "crates/stdlib" }
-revive-build-utils = { version = "0.1.0-dev.13", path = "crates/build-utils" }
+resolc  = { version = "0.1.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.0", path = "crates/integration" }
+revive-linker = { version = "0.1.0", path = "crates/linker" }
+lld-sys = { version = "0.1.0", path = "crates/lld-sys" }
+revive-llvm-context = { version = "0.1.0", path = "crates/llvm-context" }
+revive-runtime-api = { version = "0.1.0", path = "crates/runtime-api" }
+revive-runner = { version = "0.1.0", path = "crates/runner" }
+revive-solc-json-interface = { version = "0.1.0", path = "crates/solc-json-interface" }
+revive-stdlib = { version = "0.1.0", path = "crates/stdlib" }
+revive-build-utils = { version = "0.1.0", path = "crates/build-utils" }
+revive-yul = { version = "0.1.0", path = "crates/yul" }

 hex = "0.4.3"
 cc = "1.2"
-libc = "0.2.169"
-tempfile = "3.17"
+libc = "0.2.172"
+tempfile = "3.20"
 anyhow = "1.0"
 semver = { version = "1.0", features = ["serde"] }
 itertools = "0.14"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["arbitrary_precision"] }
-regex = "1.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,16 +72,15 @@ 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 = { git = "https://github.com/paritytech/polkadot-sdk", rev = "c29e72a8628835e34deb6aa7db9a78a2e4eabcee" }
+polkadot-sdk = { version = "2503.0.1" }

 # llvm
 [workspace.dependencies.inkwell]
-git = "https://github.com/TheDan64/inkwell.git"
-rev = "7b410298b6a93450adaa90b1841d5805a3038f12"
+version = "0.6.0"
 default-features = false
-features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
+features = ["serde", "llvm18-1", "no-libffi-linking", "target-riscv"]

 [profile.bench]
 inherits = "release"
@@ -1,4 +1,4 @@
-FROM rust:1.84.0 AS llvm-builder
+FROM rust:1.85.0 AS llvm-builder
 WORKDIR /opt/revive

 RUN apt update && \ 
@@ -11,7 +11,7 @@ RUN make install-llvm-builder
 RUN revive-llvm --target-env musl clone
 RUN revive-llvm --target-env musl build  --llvm-projects lld --llvm-projects clang

-FROM messense/rust-musl-cross@sha256:68b86bc7cb2867259e6b233415a665ff4469c28b57763e78c3bfea1c68091561 AS resolc-builder
+FROM messense/rust-musl-cross@sha256:c0154e992adb791c3b848dd008939d19862549204f8cb26f5ca7a00f629e6067 AS resolc-builder
 WORKDIR /opt/revive

 RUN apt update && \ 
@@ -5,12 +5,13 @@
 	install-wasm \
 	install-llvm-builder \
 	install-llvm \
+	install-revive-runner \
 	format \
 	clippy \
 	machete \
 	test \
 	test-integration \
-	test-solidity \
+	test-resolc \
 	test-workspace \
 	test-cli \
 	test-wasm \
@@ -23,22 +24,25 @@
 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 --locked --force --path crates/runner --no-default-features
+
 format:
 	cargo fmt --all --check

@@ -49,13 +53,13 @@ machete:
 	cargo install cargo-machete
 	cargo machete

-test: format clippy machete test-cli test-workspace
+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
@@ -86,9 +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 ; \
-	cargo uninstall revive-llvm-builder ; \
-	rm -f package-lock.json ; \
-	rm -rf js/dist ; \
-	rm -f js/src/resolc.{wasm,js}
+	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,15 +4,19 @@ 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 updates the versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly.
 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

+# `resolc` NPM package release
+
+Will happen automatically.
+
 # LLVM release

 To create a new LLVM release, run "Release LLVM" workflow. Use current LLVM version as parameter, e.g. `18.1.8`.
@@ -1,30 +0,0 @@
-# Known issues
-
-The following is known and we are either working on it or it is a hard limitation. Please do not open a new issue.
-
-## Release
-
-`0.1.0-dev-2`
-
-## Missing features
-
- [Libraries with public functions are not supported](https://github.com/paritytech/revive/issues/91)
- [Automatic import resolution is not supported](https://github.com/paritytech/revive/issues/98)
- The emulated EVM linear contract memory is limited to 64kb in size. Will be fixed with support for metered dynamic memory.
- [The contract calldata is currently limited to 1kb in size](https://github.com/paritytech/revive/issues/57)
- [EIP-4844 opcodes are not supported](https://github.com/paritytech/revive/issues/64)
- [Delegate calls are not supported](https://github.com/paritytech/revive/issues/67)
- [The `blockhash` opcode is not supported](https://github.com/paritytech/revive/issues/61)
- [The `extcodesize` opcode is not supported](https://github.com/paritytech/revive/issues/58)
- [The `origin` opcode is not supported](https://github.com/paritytech/revive/issues/59)
- [Gas limits for contract calls are ignored](https://github.com/paritytech/revive/issues/60)
- [Gas related opcodes are not supported](https://github.com/paritytech/revive/issues/60)
- IPFS metadata hashes are not supported
- [Compiled contract artifacts can exceed the pallet static memory limit and fail to deploy](https://github.com/paritytech/revive/issues/96).
- [Transfers to inexistant accounts will fail if the transferred value lies below the ED.](https://github.com/paritytech/revive/issues/83) Will be fixed in the pallet to make the ED completely transparent for contracts.
-
-## Wontfix
-
-Please consult our documentation to learn more about Solidity and EVM features likely to remain unsupported (and why they will not be supported).
-
-TODO: Insert link to the relevant documentation section.
@@ -15,58 +15,58 @@

 ### Baseline

-|         | `EVM`                   | `PVMInterpreter`                 |
-|:--------|:------------------------|:-------------------------------- |
-| **`0`** | `3.36 us` (✅ **1.00x**) | `11.84 us` (❌ *3.52x slower*)    |
+|         | `EVM`                    | `PVMInterpreter`                 |
+|:--------|:-------------------------|:-------------------------------- |
+| **`0`** | `10.08 us` (✅ **1.00x**) | `10.32 us` (✅ **1.02x slower**)  |

 ### OddPorduct

-|              | `EVM`                    | `PVMInterpreter`                 |
-|:-------------|:-------------------------|:-------------------------------- |
-| **`10000`**  | `3.11 ms` (✅ **1.00x**)  | `1.53 ms` (🚀 **2.03x faster**)   |
-| **`100000`** | `30.70 ms` (✅ **1.00x**) | `15.54 ms` (🚀 **1.98x faster**)  |
-| **`300000`** | `92.68 ms` (✅ **1.00x**) | `45.47 ms` (🚀 **2.04x faster**)  |
+|              | `EVM`                     | `PVMInterpreter`                 |
+|:-------------|:--------------------------|:-------------------------------- |
+| **`10000`**  | `3.60 ms` (✅ **1.00x**)   | `1.57 ms` (🚀 **2.28x faster**)   |
+| **`100000`** | `34.72 ms` (✅ **1.00x**)  | `14.82 ms` (🚀 **2.34x faster**)  |
+| **`300000`** | `105.01 ms` (✅ **1.00x**) | `44.11 ms` (🚀 **2.38x faster**)  |

 ### TriangleNumber

 |              | `EVM`                    | `PVMInterpreter`                 |
 |:-------------|:-------------------------|:-------------------------------- |
-| **`10000`**  | `2.29 ms` (✅ **1.00x**)  | `1.09 ms` (🚀 **2.11x faster**)   |
-| **`100000`** | `22.84 ms` (✅ **1.00x**) | `10.66 ms` (🚀 **2.14x faster**)  |
-| **`360000`** | `82.29 ms` (✅ **1.00x**) | `37.01 ms` (🚀 **2.22x faster**)  |
+| **`10000`**  | `2.43 ms` (✅ **1.00x**)  | `1.12 ms` (🚀 **2.17x faster**)   |
+| **`100000`** | `24.20 ms` (✅ **1.00x**) | `10.86 ms` (🚀 **2.23x faster**)  |
+| **`360000`** | `88.69 ms` (✅ **1.00x**) | `38.46 ms` (🚀 **2.31x faster**)  |

 ### FibonacciRecursive

 |          | `EVM`                     | `PVMInterpreter`                  |
 |:---------|:--------------------------|:--------------------------------- |
-| **`12`** | `135.67 us` (✅ **1.00x**) | `125.02 us` (✅ **1.09x faster**)  |
-| **`16`** | `903.75 us` (✅ **1.00x**) | `762.79 us` (✅ **1.18x faster**)  |
-| **`20`** | `6.12 ms` (✅ **1.00x**)   | `4.96 ms` (✅ **1.23x faster**)    |
-| **`24`** | `42.05 ms` (✅ **1.00x**)  | `33.86 ms` (✅ **1.24x faster**)   |
+| **`12`** | `144.17 us` (✅ **1.00x**) | `150.85 us` (✅ **1.05x slower**)  |
+| **`16`** | `938.71 us` (✅ **1.00x**) | `922.11 us` (✅ **1.02x faster**)  |
+| **`20`** | `6.54 ms` (✅ **1.00x**)   | `6.20 ms` (✅ **1.05x faster**)    |
+| **`24`** | `45.73 ms` (✅ **1.00x**)  | `41.98 ms` (✅ **1.09x faster**)   |

 ### FibonacciIterative

 |           | `EVM`                    | `PVMInterpreter`                 |
 |:----------|:-------------------------|:-------------------------------- |
-| **`64`**  | `15.04 us` (✅ **1.00x**) | `29.45 us` (❌ *1.96x slower*)    |
-| **`128`** | `26.36 us` (✅ **1.00x**) | `42.19 us` (❌ *1.60x slower*)    |
-| **`256`** | `48.61 us` (✅ **1.00x**) | `65.71 us` (❌ *1.35x slower*)    |
+| **`64`**  | `23.00 us` (✅ **1.00x**) | `31.88 us` (❌ *1.39x slower*)    |
+| **`128`** | `35.28 us` (✅ **1.00x**) | `42.43 us` (❌ *1.20x slower*)    |
+| **`256`** | `60.12 us` (✅ **1.00x**) | `61.20 us` (✅ **1.02x slower**)  |

 ### FibonacciBinet

 |           | `EVM`                    | `PVMInterpreter`                 |
 |:----------|:-------------------------|:-------------------------------- |
-| **`64`**  | `15.22 us` (✅ **1.00x**) | `41.46 us` (❌ *2.72x slower*)    |
-| **`128`** | `17.05 us` (✅ **1.00x**) | `42.84 us` (❌ *2.51x slower*)    |
-| **`256`** | `19.00 us` (✅ **1.00x**) | `44.36 us` (❌ *2.34x slower*)    |
+| **`64`**  | `23.01 us` (✅ **1.00x**) | `47.74 us` (❌ *2.07x slower*)    |
+| **`128`** | `25.44 us` (✅ **1.00x**) | `49.67 us` (❌ *1.95x slower*)    |
+| **`256`** | `28.66 us` (✅ **1.00x**) | `53.01 us` (❌ *1.85x slower*)    |

 ### SHA1

 |           | `EVM`                     | `PVMInterpreter`                  |
 |:----------|:--------------------------|:--------------------------------- |
-| **`1`**   | `110.04 us` (✅ **1.00x**) | `216.11 us` (❌ *1.96x slower*)    |
-| **`64`**  | `209.04 us` (✅ **1.00x**) | `309.48 us` (❌ *1.48x slower*)    |
-| **`512`** | `903.65 us` (✅ **1.00x**) | `980.49 us` (✅ **1.09x slower**)  |
+| **`1`**   | `135.87 us` (✅ **1.00x**) | `243.75 us` (❌ *1.79x slower*)    |
+| **`64`**  | `258.45 us` (✅ **1.00x**) | `355.70 us` (❌ *1.38x slower*)    |
+| **`512`** | `1.10 ms` (✅ **1.00x**)   | `1.09 ms` (✅ **1.01x faster**)    |

 ---
 Made with [criterion-table](https://github.com/nu11ptr/criterion-table)
@@ -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": 1443,
-  "Computation": 2788,
-  "DivisionArithmetics": 9748,
-  "ERC20": 19150,
-  "Events": 2201,
-  "FibonacciIterative": 2041,
-  "Flipper": 2691,
-  "SHA1": 8997
+  "Baseline": 939,
+  "Computation": 2282,
+  "DivisionArithmetics": 8849,
+  "ERC20": 18308,
+  "Events": 1640,
+  "FibonacciIterative": 1497,
+  "Flipper": 2099,
+  "SHA1": 8243
 }
@@ -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 {
@@ -117,13 +117,7 @@ pub fn build(
    log::info!("building compiler-rt for rv64emac");

    crate::utils::check_presence("cmake")?;
-
-    let generator = if cfg!(target_os = "windows") {
-        "Visual Studio 17 2022"
-    } else {
-        crate::utils::check_presence("ninja")?;
-        "Ninja"
-    };
+    crate::utils::check_presence("ninja")?;

    let llvm_module_compiler_rt = crate::LLVMPath::llvm_module_compiler_rt()?;
    let llvm_compiler_rt_build = crate::LLVMPath::llvm_build_compiler_rt()?;
@@ -136,7 +130,7 @@ pub fn build(
                "-B",
                llvm_compiler_rt_build.to_string_lossy().as_ref(),
                "-G",
-                generator,
+                "Ninja",
            ])
            .args(CMAKE_STATIC_ARGS)
            .args(cmake_dynamic_args(build_type, target_env)?)
@@ -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.
 ///
@@ -28,6 +28,7 @@ pub use self::polkavm::context::function::runtime::entry::Entry as PolkaVMEntryF
 pub use self::polkavm::context::function::runtime::revive::Exit as PolkaVMExitFunction;
 pub use self::polkavm::context::function::runtime::revive::WordToPointer as PolkaVMWordToPointerFunction;
 pub use self::polkavm::context::function::runtime::runtime_code::RuntimeCode as PolkaVMRuntimeCodeFunction;
+pub use self::polkavm::context::function::runtime::sbrk::Sbrk as PolkaVMSbrkFunction;
 pub use self::polkavm::context::function::runtime::FUNCTION_DEPLOY_CODE as PolkaVMFunctionDeployCode;
 pub use self::polkavm::context::function::runtime::FUNCTION_ENTRY as PolkaVMFunctionEntry;
 pub use self::polkavm::context::function::runtime::FUNCTION_RUNTIME_CODE as PolkaVMFunctionRuntimeCode;
@@ -60,7 +61,6 @@ pub use self::polkavm::evm::ext_code as polkavm_evm_ext_code;
 pub use self::polkavm::evm::immutable as polkavm_evm_immutable;
 pub use self::polkavm::evm::immutable::Load as PolkaVMLoadImmutableDataFunction;
 pub use self::polkavm::evm::immutable::Store as PolkaVMStoreImmutableDataFunction;
-
 pub use self::polkavm::evm::math as polkavm_evm_math;
 pub use self::polkavm::evm::memory as polkavm_evm_memory;
 pub use self::polkavm::evm::r#return as polkavm_evm_return;
@@ -234,7 +234,7 @@ impl TryFrom<&SolcStandardJsonInputSettingsOptimizer> for Settings {
    fn try_from(value: &SolcStandardJsonInputSettingsOptimizer) -> Result<Self, Self::Error> {
        let mut result = match value.mode {
            Some(mode) => Self::try_from_cli(mode)?,
-            None => Self::cycles(),
+            None => Self::size(),
        };
        if value.fallback_to_optimizing_for_size.unwrap_or_default() {
            result.enable_fallback_to_size();
@@ -9,6 +9,15 @@ pub static XLEN: usize = revive_common::BIT_LENGTH_X32;
 /// The calldata size global variable name.
 pub static GLOBAL_CALLDATA_SIZE: &str = "calldatasize";

+/// The heap size global variable name.
+pub static GLOBAL_HEAP_SIZE: &str = "__heap_size";
+
+/// The heap memory global variable name.
+pub static GLOBAL_HEAP_MEMORY: &str = "__heap_memory";
+
+/// The spill buffer global variable name.
+pub static GLOBAL_ADDRESS_SPILL_BUFFER: &str = "address_spill_buffer";
+
 /// The deployer call header size that consists of:
 /// - bytecode hash (32 bytes)
 pub const DEPLOYER_CALL_HEADER_SIZE: usize = revive_common::BYTE_LENGTH_WORD;
@@ -4,61 +4,98 @@
 #[derive(Debug, Clone)]
 pub struct Argument<'ctx> {
    /// The actual LLVM operand.
-    pub value: inkwell::values::BasicValueEnum<'ctx>,
+    pub value: Value<'ctx>,
    /// The original AST value. Used mostly for string literals.
    pub original: Option<String>,
    /// The preserved constant value, if available.
    pub constant: Option<num::BigUint>,
 }

+/// The function argument can be either a pointer or a integer value.
+/// This disambiguation allows for lazy loading of variables.
+#[derive(Clone, Debug)]
+pub enum Value<'ctx> {
+    Register(inkwell::values::BasicValueEnum<'ctx>),
+    Pointer {
+        pointer: crate::polkavm::context::Pointer<'ctx>,
+        id: String,
+    },
+}
+
 impl<'ctx> Argument<'ctx> {
-    /// The calldata offset argument index.
-    pub const ARGUMENT_INDEX_CALLDATA_OFFSET: usize = 0;
-
-    /// The calldata length argument index.
-    pub const ARGUMENT_INDEX_CALLDATA_LENGTH: usize = 1;
-
-    /// A shortcut constructor.
-    pub fn new(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
+    /// A shortcut constructor for register arguments.
+    pub fn value(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
        Self {
-            value,
+            value: Value::Register(value),
            original: None,
            constant: None,
        }
    }

-    /// A shortcut constructor.
-    pub fn new_with_original(
-        value: inkwell::values::BasicValueEnum<'ctx>,
-        original: String,
-    ) -> Self {
+    /// A shortcut constructor for stack arguments.
+    pub fn pointer(pointer: crate::polkavm::context::Pointer<'ctx>, id: String) -> Self {
        Self {
-            value,
-            original: Some(original),
+            value: Value::Pointer { pointer, id },
+            original: None,
            constant: None,
        }
    }

-    /// A shortcut constructor.
-    pub fn new_with_constant(
-        value: inkwell::values::BasicValueEnum<'ctx>,
-        constant: num::BigUint,
-    ) -> Self {
-        Self {
-            value,
-            original: None,
-            constant: Some(constant),
-        }
+    /// Set the original decleratation value.
+    pub fn with_original(mut self, original: String) -> Self {
+        self.original = Some(original);
+        self
+    }
+
+    /// Set the constant value.
+    pub fn with_constant(mut self, constant: num::BigUint) -> Self {
+        self.constant = Some(constant);
+        self
    }

    /// Returns the inner LLVM value.
-    pub fn to_llvm(&self) -> inkwell::values::BasicValueEnum<'ctx> {
-        self.value
+    ///
+    /// Panics if `self` is a pointer argument.
+    pub fn _to_llvm_value(&self) -> inkwell::values::BasicValueEnum<'ctx> {
+        match &self.value {
+            Value::Register(value) => *value,
+            Value::Pointer { .. } => unreachable!("invalid register value access"),
+        }
+    }
+
+    /// Access the underlying value.
+    ///
+    /// Will emit a stack load if `self` is a pointer argument.
+    pub fn access<D: crate::polkavm::Dependency + Clone>(
+        &self,
+        context: &crate::polkavm::context::Context<'ctx, D>,
+    ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>> {
+        match &self.value {
+            Value::Register(value) => Ok(*value),
+            Value::Pointer { pointer, id } => context.build_load(*pointer, id),
+        }
+    }
+
+    /// Access the underlying value.
+    ///
+    /// Will emit a stack load if `self` is a pointer argument.
+    pub fn as_pointer<D: crate::polkavm::Dependency + Clone>(
+        &self,
+        context: &crate::polkavm::context::Context<'ctx, D>,
+    ) -> anyhow::Result<crate::polkavm::context::Pointer<'ctx>> {
+        match &self.value {
+            Value::Register(value) => {
+                let pointer = context.build_alloca_at_entry(context.word_type(), "pvm_arg");
+                context.build_store(pointer, *value)?;
+                Ok(pointer)
+            }
+            Value::Pointer { pointer, .. } => Ok(*pointer),
+        }
    }
 }

 impl<'ctx> From<inkwell::values::BasicValueEnum<'ctx>> for Argument<'ctx> {
    fn from(value: inkwell::values::BasicValueEnum<'ctx>) -> Self {
-        Self::new(value)
+        Self::value(value)
    }
 }
@@ -31,6 +31,31 @@ impl Entry {
            context.xlen_type().get_undef(),
        );

+        context.set_global(
+            crate::polkavm::GLOBAL_HEAP_SIZE,
+            context.xlen_type(),
+            AddressSpace::Stack,
+            context.xlen_type().const_zero(),
+        );
+
+        let heap_memory_type = context
+            .byte_type()
+            .array_type(context.memory_config.heap_size);
+        context.set_global(
+            crate::polkavm::GLOBAL_HEAP_MEMORY,
+            heap_memory_type,
+            AddressSpace::Stack,
+            heap_memory_type.const_zero(),
+        );
+
+        let address_type = context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS);
+        context.set_global(
+            crate::polkavm::GLOBAL_ADDRESS_SPILL_BUFFER,
+            address_type,
+            AddressSpace::Stack,
+            address_type.const_zero(),
+        );
+
        Ok(())
    }

@@ -5,6 +5,7 @@ pub mod deploy_code;
 pub mod entry;
 pub mod revive;
 pub mod runtime_code;
+pub mod sbrk;

 /// The main entry function name.
 pub const FUNCTION_ENTRY: &str = "__entry";
@@ -0,0 +1,144 @@
+//! Emulates the linear EVM heap memory via a simulated `sbrk` system call.
+
+use inkwell::values::BasicValue;
+
+use crate::polkavm::context::attribute::Attribute;
+use crate::polkavm::context::runtime::RuntimeFunction;
+use crate::polkavm::context::Context;
+use crate::polkavm::Dependency;
+use crate::polkavm::WriteLLVM;
+
+/// Simulates the `sbrk` system call, reproducing the semantics of the EVM heap memory.
+///
+/// Parameters:
+/// - The `offset` into the emulated EVM heap memory.
+/// - The `size` of the allocation emulated EVM heap memory.
+///
+/// Returns:
+/// - A pointer to the EVM heap memory at given `offset`.
+///
+/// Semantics:
+/// - Traps if the offset is out of bounds.
+/// - Aligns the total heap memory size to the EVM word size.
+/// - Traps if the memory size would be greater than the configured EVM heap memory size.
+/// - Maintains the total memory size (`msize`) in global heap size value.
+pub struct Sbrk;
+
+impl<D> RuntimeFunction<D> for Sbrk
+where
+    D: Dependency + Clone,
+{
+    const NAME: &'static str = "__sbrk_internal";
+
+    const ATTRIBUTES: &'static [Attribute] = &[
+        Attribute::NoFree,
+        Attribute::NoRecurse,
+        Attribute::WillReturn,
+    ];
+
+    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
+        context.llvm().ptr_type(Default::default()).fn_type(
+            &[context.xlen_type().into(), context.xlen_type().into()],
+            false,
+        )
+    }
+
+    fn emit_body<'ctx>(
+        &self,
+        context: &mut Context<'ctx, D>,
+    ) -> anyhow::Result<Option<inkwell::values::BasicValueEnum<'ctx>>> {
+        let offset = Self::paramater(context, 0).into_int_value();
+        let size = Self::paramater(context, 1).into_int_value();
+
+        let trap_block = context.append_basic_block("trap");
+        let offset_in_bounds_block = context.append_basic_block("offset_in_bounds");
+        let is_offset_out_of_bounds = context.builder().build_int_compare(
+            inkwell::IntPredicate::UGE,
+            offset,
+            context.heap_size(),
+            "offset_out_of_bounds",
+        )?;
+        context.build_conditional_branch(
+            is_offset_out_of_bounds,
+            trap_block,
+            offset_in_bounds_block,
+        )?;
+
+        context.set_basic_block(trap_block);
+        context.build_call(context.intrinsics().trap, &[], "invalid_trap");
+        context.build_unreachable();
+
+        context.set_basic_block(offset_in_bounds_block);
+        let mask = context
+            .xlen_type()
+            .const_int(revive_common::BYTE_LENGTH_WORD as u64 - 1, false);
+        let total_size = context
+            .builder()
+            .build_int_add(offset, size, "total_size")?;
+        let memory_size = context.builder().build_and(
+            context.builder().build_int_add(total_size, mask, "mask")?,
+            context.builder().build_not(mask, "mask_not")?,
+            "memory_size",
+        )?;
+        let size_in_bounds_block = context.append_basic_block("size_in_bounds");
+        let is_size_out_of_bounds = context.builder().build_int_compare(
+            inkwell::IntPredicate::UGT,
+            memory_size,
+            context.heap_size(),
+            "size_out_of_bounds",
+        )?;
+        context.build_conditional_branch(
+            is_size_out_of_bounds,
+            trap_block,
+            size_in_bounds_block,
+        )?;
+
+        context.set_basic_block(size_in_bounds_block);
+        let return_block = context.append_basic_block("return_pointer");
+        let new_size_block = context.append_basic_block("new_size");
+        let is_new_size = context.builder().build_int_compare(
+            inkwell::IntPredicate::UGT,
+            memory_size,
+            context
+                .get_global_value(crate::polkavm::GLOBAL_HEAP_SIZE)?
+                .into_int_value(),
+            "is_new_size",
+        )?;
+        context.build_conditional_branch(is_new_size, new_size_block, return_block)?;
+
+        context.set_basic_block(new_size_block);
+        context.build_store(
+            context.get_global(crate::polkavm::GLOBAL_HEAP_SIZE)?.into(),
+            memory_size,
+        )?;
+        context.build_unconditional_branch(return_block);
+
+        context.set_basic_block(return_block);
+        Ok(Some(
+            context
+                .build_gep(
+                    context
+                        .get_global(crate::polkavm::GLOBAL_HEAP_MEMORY)?
+                        .into(),
+                    &[context.xlen_type().const_zero(), offset],
+                    context.byte_type(),
+                    "allocation_start_pointer",
+                )
+                .value
+                .as_basic_value_enum(),
+        ))
+    }
+}
+
+impl<D> WriteLLVM<D> for Sbrk
+where
+    D: Dependency + Clone,
+{
+    fn declare(&mut self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::declare(self, context)
+    }
+
+    fn into_llvm(self, context: &mut Context<D>) -> anyhow::Result<()> {
+        <Self as RuntimeFunction<_>>::emit(&self, context)
+    }
+}
@@ -25,6 +25,7 @@ use inkwell::debug_info::AsDIScope;
 use inkwell::debug_info::DIScope;
 use inkwell::types::BasicType;
 use inkwell::values::BasicValue;
+use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory;

 use crate::optimizer::settings::Settings as OptimizerSettings;
 use crate::optimizer::Optimizer;
@@ -33,6 +34,7 @@ use crate::polkavm::Dependency;
 use crate::target_machine::target::Target;
 use crate::target_machine::TargetMachine;
 use crate::PolkaVMLoadHeapWordFunction;
+use crate::PolkaVMSbrkFunction;
 use crate::PolkaVMStoreHeapWordFunction;

 use self::address_space::AddressSpace;
@@ -85,6 +87,8 @@ where
    loop_stack: Vec<Loop<'ctx>>,
    /// The extra LLVM arguments that were used during target initialization.
    llvm_arguments: &'ctx [String],
+    /// The PVM memory configuration.
+    memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,

    /// The project dependency manager. It can be any entity implementing the trait.
    /// The manager is used to get information about contracts and their dependencies during
@@ -116,9 +120,6 @@ where
    /// The loop stack default capacity.
    const LOOP_STACK_INITIAL_CAPACITY: usize = 16;

-    /// The PolkaVM minimum stack size.
-    const POLKAVM_STACK_SIZE: u32 = 0x4000;
-
    /// Link in the stdlib module.
    fn link_stdlib_module(
        llvm: &'ctx inkwell::context::Context,
@@ -218,6 +219,7 @@ where
    }

    /// Initializes a new LLVM context.
+    #[allow(clippy::too_many_arguments)]
    pub fn new(
        llvm: &'ctx inkwell::context::Context,
        module: inkwell::module::Module<'ctx>,
@@ -226,11 +228,12 @@ where
        include_metadata_hash: bool,
        debug_config: DebugConfig,
        llvm_arguments: &'ctx [String],
+        memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> Self {
        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, Self::POLKAVM_STACK_SIZE);
+        Self::set_polkavm_stack_size(llvm, &module, memory_config.stack_size);
        Self::set_module_flags(llvm, &module);

        let intrinsics = Intrinsics::new(llvm, &module);
@@ -254,6 +257,7 @@ where
            current_function: None,
            loop_stack: Vec::with_capacity(Self::LOOP_STACK_INITIAL_CAPACITY),
            llvm_arguments,
+            memory_config,

            dependency_manager,
            include_metadata_hash,
@@ -644,6 +648,7 @@ where
                    self.include_metadata_hash,
                    self.debug_config.clone(),
                    self.llvm_arguments,
+                    self.memory_config,
                )
            })
    }
@@ -750,7 +755,9 @@ where
        address: inkwell::values::IntValue<'ctx>,
    ) -> anyhow::Result<Pointer<'ctx>> {
        let address_type = self.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS);
-        let address_pointer = self.build_alloca_at_entry(address_type, "address_pointer");
+        let address_pointer = self
+            .get_global(crate::polkavm::GLOBAL_ADDRESS_SPILL_BUFFER)?
+            .into();
        let address_truncated =
            self.builder()
                .build_int_truncate(address, address_type, "address_truncated")?;
@@ -1082,32 +1089,40 @@ where
        offset: inkwell::values::IntValue<'ctx>,
        size: inkwell::values::IntValue<'ctx>,
    ) -> anyhow::Result<inkwell::values::PointerValue<'ctx>> {
-        Ok(self
-            .builder()
-            .build_call(
-                self.runtime_api_method(revive_runtime_api::polkavm_imports::SBRK),
-                &[offset.into(), size.into()],
-                "call_sbrk",
-            )?
+        let call_site_value = self.builder().build_call(
+            <PolkaVMSbrkFunction as RuntimeFunction<D>>::declaration(self).function_value(),
+            &[offset.into(), size.into()],
+            "alloc_start",
+        )?;
+
+        call_site_value.add_attribute(
+            inkwell::attributes::AttributeLoc::Return,
+            self.llvm
+                .create_enum_attribute(Attribute::NonNull as u32, 0),
+        );
+        call_site_value.add_attribute(
+            inkwell::attributes::AttributeLoc::Return,
+            self.llvm
+                .create_enum_attribute(Attribute::NoUndef as u32, 0),
+        );
+
+        Ok(call_site_value
            .try_as_basic_value()
            .left()
-            .expect("sbrk returns a pointer")
+            .unwrap_or_else(|| {
+                panic!(
+                    "revive runtime function {} should return a value",
+                    <PolkaVMSbrkFunction as RuntimeFunction<D>>::NAME,
+                )
+            })
            .into_pointer_value())
    }

    /// Build a call to PolkaVM `msize` for querying the linear memory size.
    pub fn build_msize(&self) -> anyhow::Result<inkwell::values::IntValue<'ctx>> {
-        let memory_size_pointer = self
-            .module()
-            .get_global(revive_runtime_api::polkavm_imports::MEMORY_SIZE)
-            .expect("the memory size symbol should have been declared")
-            .as_pointer_value();
-        let memory_size_value = self.builder().build_load(
-            self.xlen_type(),
-            memory_size_pointer,
-            "memory_size_value",
-        )?;
-        Ok(memory_size_value.into_int_value())
+        Ok(self
+            .get_global_value(crate::polkavm::GLOBAL_HEAP_SIZE)?
+            .into_int_value())
    }

    /// Returns a pointer to `offset` into the heap, allocating
@@ -1426,4 +1441,9 @@ where
    pub fn optimizer_settings(&self) -> &OptimizerSettings {
        self.optimizer.settings()
    }
+
+    pub fn heap_size(&self) -> inkwell::values::IntValue<'ctx> {
+        self.xlen_type()
+            .const_int(self.memory_config.heap_size as u64, false)
+    }
 }
@@ -19,7 +19,7 @@ where
    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
        context
            .word_type()
-            .fn_type(&[context.word_type().into()], false)
+            .fn_type(&[context.llvm().ptr_type(Default::default()).into()], false)
    }

    fn emit_body<'ctx>(
@@ -59,7 +59,7 @@ where
    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
        context
            .word_type()
-            .fn_type(&[context.word_type().into()], false)
+            .fn_type(&[context.llvm().ptr_type(Default::default()).into()], false)
    }

    fn emit_body<'ctx>(
@@ -94,7 +94,10 @@ where

    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
        context.void_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
+            &[
+                context.llvm().ptr_type(Default::default()).into(),
+                context.llvm().ptr_type(Default::default()).into(),
+            ],
            false,
        )
    }
@@ -138,7 +141,10 @@ where

    fn r#type<'ctx>(context: &Context<'ctx, D>) -> inkwell::types::FunctionType<'ctx> {
        context.void_type().fn_type(
-            &[context.word_type().into(), context.word_type().into()],
+            &[
+                context.llvm().ptr_type(Default::default()).into(),
+                context.llvm().ptr_type(Default::default()).into(),
+            ],
            false,
        )
    }
@@ -173,9 +179,17 @@ where

 fn emit_load<'ctx, D: Dependency + Clone>(
    context: &mut Context<'ctx, D>,
-    mut key: BasicValueEnum<'ctx>,
+    key: BasicValueEnum<'ctx>,
    transient: bool,
 ) -> anyhow::Result<BasicValueEnum<'ctx>> {
+    let mut key = context.build_load(
+        super::Pointer::new(
+            context.word_type(),
+            Default::default(),
+            key.into_pointer_value(),
+        ),
+        "key",
+    )?;
    if !transient {
        key = context.build_byte_swap(key)?;
    }
@@ -217,10 +231,26 @@ fn emit_load<'ctx, D: Dependency + Clone>(

 fn emit_store<'ctx, D: Dependency + Clone>(
    context: &mut Context<'ctx, D>,
-    mut key: BasicValueEnum<'ctx>,
-    mut value: BasicValueEnum<'ctx>,
+    key: BasicValueEnum<'ctx>,
+    value: BasicValueEnum<'ctx>,
    transient: bool,
 ) -> anyhow::Result<()> {
+    let mut key = context.build_load(
+        super::Pointer::new(
+            context.word_type(),
+            Default::default(),
+            key.into_pointer_value(),
+        ),
+        "key",
+    )?;
+    let mut value = context.build_load(
+        super::Pointer::new(
+            context.word_type(),
+            Default::default(),
+            value.into_pointer_value(),
+        ),
+        "key",
+    )?;
    if !transient {
        key = context.build_byte_swap(key)?;
        value = context.build_byte_swap(value)?;
@@ -23,6 +23,7 @@ pub fn create_context(
        true,
        Default::default(),
        Default::default(),
+        Default::default(),
    )
 }

@@ -63,7 +63,6 @@ where
    let non_overflow_block = context.append_basic_block("shift_left_non_overflow");
    let join_block = context.append_basic_block("shift_left_join");

-    let result_pointer = context.build_alloca(context.word_type(), "shift_left_result_pointer");
    let condition_is_overflow = context.builder().build_int_compare(
        inkwell::IntPredicate::UGT,
        shift,
@@ -73,7 +72,6 @@ where
    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;

    context.set_basic_block(overflow_block);
-    context.build_store(result_pointer, context.word_const(0))?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(non_overflow_block);
@@ -81,11 +79,17 @@ where
        context
            .builder()
            .build_left_shift(value, shift, "shift_left_non_overflow_result")?;
-    context.build_store(result_pointer, value)?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(join_block);
-    context.build_load(result_pointer, "shift_left_result")
+    let result = context
+        .builder()
+        .build_phi(context.word_type(), "shift_left_value")?;
+    result.add_incoming(&[
+        (&value, non_overflow_block),
+        (&context.word_const(0), overflow_block),
+    ]);
+    Ok(result.as_basic_value())
 }

 /// Translates the bitwise shift right.
@@ -101,7 +105,6 @@ where
    let non_overflow_block = context.append_basic_block("shift_right_non_overflow");
    let join_block = context.append_basic_block("shift_right_join");

-    let result_pointer = context.build_alloca(context.word_type(), "shift_right_result_pointer");
    let condition_is_overflow = context.builder().build_int_compare(
        inkwell::IntPredicate::UGT,
        shift,
@@ -111,7 +114,6 @@ where
    context.build_conditional_branch(condition_is_overflow, overflow_block, non_overflow_block)?;

    context.set_basic_block(overflow_block);
-    context.build_store(result_pointer, context.word_const(0))?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(non_overflow_block);
@@ -121,11 +123,17 @@ where
        false,
        "shift_right_non_overflow_result",
    )?;
-    context.build_store(result_pointer, value)?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(join_block);
-    context.build_load(result_pointer, "shift_right_result")
+    let result = context
+        .builder()
+        .build_phi(context.word_type(), "shift_right_value")?;
+    result.add_incoming(&[
+        (&value, non_overflow_block),
+        (&context.word_const(0), overflow_block),
+    ]);
+    Ok(result.as_basic_value())
 }

 /// Translates the arithmetic bitwise shift right.
@@ -145,8 +153,6 @@ where
    let non_overflow_block = context.append_basic_block("shift_right_arithmetic_non_overflow");
    let join_block = context.append_basic_block("shift_right_arithmetic_join");

-    let result_pointer =
-        context.build_alloca(context.word_type(), "shift_right_arithmetic_result_pointer");
    let condition_is_overflow = context.builder().build_int_compare(
        inkwell::IntPredicate::UGT,
        shift,
@@ -174,11 +180,9 @@ where
    )?;

    context.set_basic_block(overflow_positive_block);
-    context.build_store(result_pointer, context.word_const(0))?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(overflow_negative_block);
-    context.build_store(result_pointer, context.word_type().const_all_ones())?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(non_overflow_block);
@@ -188,11 +192,21 @@ where
        true,
        "shift_right_arithmetic_non_overflow_result",
    )?;
-    context.build_store(result_pointer, value)?;
    context.build_unconditional_branch(join_block);

    context.set_basic_block(join_block);
-    context.build_load(result_pointer, "shift_right_arithmetic_result")
+    let result = context
+        .builder()
+        .build_phi(context.word_type(), "shift_arithmetic_right_value")?;
+    result.add_incoming(&[
+        (&value, non_overflow_block),
+        (
+            &context.word_type().const_all_ones(),
+            overflow_negative_block,
+        ),
+        (&context.word_const(0), overflow_block),
+    ]);
+    Ok(result.as_basic_value())
 }

 /// Translates the `byte` instruction, extracting the byte of `operand_2`
@@ -2,6 +2,7 @@

 use inkwell::values::BasicValue;

+use crate::polkavm::context::pointer::Pointer;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;

@@ -49,7 +50,9 @@ where
    D: Dependency + Clone,
 {
    let address_type = context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS);
-    let address_pointer = context.build_alloca_at_entry(address_type, "origin_address");
+    let address_pointer: Pointer<'_> = context
+        .get_global(crate::polkavm::GLOBAL_ADDRESS_SPILL_BUFFER)?
+        .into();
    context.build_store(address_pointer, address_type.const_zero())?;
    context.build_runtime_call(
        revive_runtime_api::polkavm_imports::ORIGIN,
@@ -97,13 +100,13 @@ where
    D: Dependency + Clone,
 {
    let output_pointer = context.build_alloca_at_entry(context.word_type(), "blockhash_out_ptr");
-    let index_ptr = context.build_alloca_at_entry(context.word_type(), "blockhash_index_ptr");
-    context.build_store(index_ptr, index)?;
+    let index_pointer = context.build_alloca_at_entry(context.word_type(), "blockhash_index_ptr");
+    context.build_store(index_pointer, index)?;

    context.build_runtime_call(
        revive_runtime_api::polkavm_imports::BLOCK_HASH,
        &[
-            index_ptr.to_int(context).into(),
+            index_pointer.to_int(context).into(),
            output_pointer.to_int(context).into(),
        ],
    );
@@ -127,10 +130,9 @@ pub fn coinbase<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let pointer = context.build_alloca_at_entry(
-        context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS),
-        "coinbase_output",
-    );
+    let pointer: Pointer<'_> = context
+        .get_global(crate::polkavm::GLOBAL_ADDRESS_SPILL_BUFFER)?
+        .into();
    context.build_runtime_call(
        revive_runtime_api::polkavm_imports::BLOCK_AUTHOR,
        &[pointer.to_int(context).into()],
@@ -155,10 +157,9 @@ pub fn address<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let pointer = context.build_alloca_at_entry(
-        context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS),
-        "address_output",
-    );
+    let pointer: Pointer<'_> = context
+        .get_global(crate::polkavm::GLOBAL_ADDRESS_SPILL_BUFFER)?
+        .into();
    context.build_runtime_call(
        revive_runtime_api::polkavm_imports::ADDRESS,
        &[pointer.to_int(context).into()],
@@ -173,10 +174,9 @@ pub fn caller<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let pointer = context.build_alloca_at_entry(
-        context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS),
-        "address_output",
-    );
+    let pointer: Pointer<'_> = context
+        .get_global(crate::polkavm::GLOBAL_ADDRESS_SPILL_BUFFER)?
+        .into();
    context.build_runtime_call(
        revive_runtime_api::polkavm_imports::CALLER,
        &[pointer.to_int(context).into()],
@@ -119,10 +119,8 @@ where
                _ => error,
            })?;
    if contract_path.as_str() == parent {
-        return Ok(Argument::new_with_constant(
-            context.word_const(0).as_basic_value_enum(),
-            num::BigUint::zero(),
-        ));
+        return Ok(Argument::value(context.word_const(0).as_basic_value_enum())
+            .with_constant(num::BigUint::zero()));
    } else if identifier.ends_with("_deployed") && code_type == CodeType::Runtime {
        anyhow::bail!("type({}).runtimeCode is not supported", identifier);
    }
@@ -131,7 +129,7 @@ where
    let hash_value = context
        .word_const_str_hex(hash_string.as_str())
        .as_basic_value_enum();
-    Ok(Argument::new_with_original(hash_value, hash_string))
+    Ok(Argument::value(hash_value).with_original(hash_string))
 }

 /// Translates the deploy call header size instruction. the header consists of
@@ -160,10 +158,8 @@ where
                _ => error,
            })?;
    if contract_path.as_str() == parent {
-        return Ok(Argument::new_with_constant(
-            context.word_const(0).as_basic_value_enum(),
-            num::BigUint::zero(),
-        ));
+        return Ok(Argument::value(context.word_const(0).as_basic_value_enum())
+            .with_constant(num::BigUint::zero()));
    } else if identifier.ends_with("_deployed") && code_type == CodeType::Runtime {
        anyhow::bail!("type({}).runtimeCode is not supported", identifier);
    }
@@ -172,5 +168,5 @@ where
    let size_value = context
        .word_const(crate::polkavm::DEPLOYER_CALL_HEADER_SIZE as u64)
        .as_basic_value_enum();
-    Ok(Argument::new_with_constant(size_value, size_bigint))
+    Ok(Argument::value(size_value).with_constant(size_bigint))
 }
@@ -28,7 +28,7 @@ pub fn value<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let output_pointer = context.build_alloca(context.value_type(), "value_transferred");
+    let output_pointer = context.build_alloca_at_entry(context.value_type(), "value_transferred");
    context.build_store(output_pointer, context.word_const(0))?;
    context.build_runtime_call(
        revive_runtime_api::polkavm_imports::VALUE_TRANSFERRED,
@@ -46,8 +46,7 @@ where
    D: Dependency + Clone,
 {
    let address_pointer = context.build_address_argument_store(address)?;
-
-    let balance_pointer = context.build_alloca(context.word_type(), "balance_pointer");
+    let balance_pointer = context.build_alloca_at_entry(context.word_type(), "balance_pointer");
    let balance = context.builder().build_ptr_to_int(
        balance_pointer.value,
        context.xlen_type(),
@@ -69,7 +68,7 @@ pub fn self_balance<'ctx, D>(
 where
    D: Dependency + Clone,
 {
-    let balance_pointer = context.build_alloca(context.word_type(), "balance_pointer");
+    let balance_pointer = context.build_alloca_at_entry(context.word_type(), "balance_pointer");
    let balance = context.builder().build_ptr_to_int(
        balance_pointer.value,
        context.xlen_type(),
@@ -3,6 +3,7 @@
 use crate::polkavm::context::runtime::RuntimeFunction;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
+use crate::PolkaVMArgument;
 use crate::PolkaVMLoadStorageWordFunction;
 use crate::PolkaVMLoadTransientStorageWordFunction;
 use crate::PolkaVMStoreStorageWordFunction;
@@ -11,14 +12,14 @@ use crate::PolkaVMStoreTransientStorageWordFunction;
 /// Translates the storage load.
 pub fn load<'ctx, D>(
    context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
    D: Dependency + Clone,
 {
    let name = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::NAME;
    let declaration = <PolkaVMLoadStorageWordFunction as RuntimeFunction<D>>::declaration(context);
-    let arguments = [position.into()];
+    let arguments = [position.as_pointer(context)?.value.into()];
    Ok(context
        .build_call(declaration, &arguments, "storage_load")
        .unwrap_or_else(|| panic!("runtime function {name} should return a value")))
@@ -27,14 +28,17 @@ where
 /// Translates the storage store.
 pub fn store<'ctx, D>(
    context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
-    value: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
+    value: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<()>
 where
    D: Dependency + Clone,
 {
    let declaration = <PolkaVMStoreStorageWordFunction as RuntimeFunction<D>>::declaration(context);
-    let arguments = [position.into(), value.into()];
+    let arguments = [
+        position.as_pointer(context)?.value.into(),
+        value.as_pointer(context)?.value.into(),
+    ];
    context.build_call(declaration, &arguments, "storage_store");
    Ok(())
 }
@@ -42,13 +46,13 @@ where
 /// Translates the transient storage load.
 pub fn transient_load<'ctx, D>(
    context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
    D: Dependency + Clone,
 {
    let name = <PolkaVMLoadTransientStorageWordFunction as RuntimeFunction<D>>::NAME;
-    let arguments = [position.into()];
+    let arguments = [position.as_pointer(context)?.value.into()];
    let declaration =
        <PolkaVMLoadTransientStorageWordFunction as RuntimeFunction<D>>::declaration(context);
    Ok(context
@@ -59,15 +63,18 @@ where
 /// Translates the transient storage store.
 pub fn transient_store<'ctx, D>(
    context: &mut Context<'ctx, D>,
-    position: inkwell::values::IntValue<'ctx>,
-    value: inkwell::values::IntValue<'ctx>,
+    position: &PolkaVMArgument<'ctx>,
+    value: &PolkaVMArgument<'ctx>,
 ) -> anyhow::Result<()>
 where
    D: Dependency + Clone,
 {
    let declaration =
        <PolkaVMStoreTransientStorageWordFunction as RuntimeFunction<D>>::declaration(context);
-    let arguments = [position.into(), value.into()];
+    let arguments = [
+        position.as_pointer(context)?.value.into(),
+        value.as_pointer(context)?.value.into(),
+    ];
    context.build_call(declaration, &arguments, "transient_storage_store");
    Ok(())
 }
@@ -12,6 +12,7 @@ use crate::optimizer::settings::Settings as OptimizerSettings;
 use anyhow::Context as AnyhowContext;
 use polkavm_common::program::ProgramBlob;
 use polkavm_disassembler::{Disassembler, DisassemblyFormat};
+use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory;
 use sha3::Digest;

 use self::context::build::Build;
@@ -90,6 +91,7 @@ pub trait Dependency {
        include_metadata_hash: bool,
        debug_config: DebugConfig,
        llvm_arguments: &[String],
+        memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> anyhow::Result<String>;

    /// Resolves a full contract path.
@@ -111,6 +113,7 @@ impl Dependency for DummyDependency {
        _include_metadata_hash: bool,
        _debug_config: DebugConfig,
        _llvm_arguments: &[String],
+        _memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> anyhow::Result<String> {
        Ok(String::new())
    }
@@ -1,5 +1,5 @@
 [package]
-name = "revive-solidity"
+name = "resolc"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
@@ -18,33 +18,30 @@ 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 }

 [target.'cfg(target_os = "emscripten")'.dependencies]
 libc = { workspace = true }
-inkwell = { workspace = true, features = ["target-riscv", "llvm18-0-no-llvm-linking"]}
+inkwell = { workspace = true, features = ["target-riscv", "llvm18-1-no-llvm-linking"]}

 [build-dependencies]
 git2 = { workspace = true, default-features = false }
@@ -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;
@@ -45,6 +44,8 @@ use revive_solc_json_interface::ResolcWarning;
 use revive_solc_json_interface::SolcStandardJsonInput;
 use revive_solc_json_interface::SolcStandardJsonInputLanguage;
 use revive_solc_json_interface::SolcStandardJsonInputSettingsOptimizer;
+use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVM;
+use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory;
 use revive_solc_json_interface::SolcStandardJsonInputSettingsSelection;

 /// Runs the Yul mode.
@@ -55,6 +56,7 @@ pub fn yul<T: Compiler>(
    include_metadata_hash: bool,
    debug_config: revive_llvm_context::DebugConfig,
    llvm_arguments: &[String],
+    memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 ) -> anyhow::Result<Build> {
    let path = match input_files.len() {
        1 => input_files.first().expect("Always exists"),
@@ -80,6 +82,7 @@ pub fn yul<T: Compiler>(
        include_metadata_hash,
        debug_config,
        llvm_arguments,
+        memory_config,
    )?;

    Ok(build)
@@ -92,6 +95,7 @@ pub fn llvm_ir(
    include_metadata_hash: bool,
    debug_config: revive_llvm_context::DebugConfig,
    llvm_arguments: &[String],
+    memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 ) -> anyhow::Result<Build> {
    let path = match input_files.len() {
        1 => input_files.first().expect("Always exists"),
@@ -109,6 +113,7 @@ pub fn llvm_ir(
        include_metadata_hash,
        debug_config,
        llvm_arguments,
+        memory_config,
    )?;

    Ok(build)
@@ -131,6 +136,7 @@ pub fn standard_output<T: Compiler>(
    suppressed_warnings: Option<Vec<ResolcWarning>>,
    debug_config: revive_llvm_context::DebugConfig,
    llvm_arguments: &[String],
+    memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 ) -> anyhow::Result<Build> {
    let solc_version = solc.version()?;

@@ -149,6 +155,10 @@ pub fn standard_output<T: Compiler>(
        ),
        None,
        suppressed_warnings,
+        Some(SolcStandardJsonInputSettingsPolkaVM::new(
+            Some(memory_config),
+            debug_config.emit_debug_info,
+        )),
    )?;

    let source_code_files = solc_input
@@ -189,19 +199,21 @@ pub fn standard_output<T: Compiler>(
        include_metadata_hash,
        debug_config,
        llvm_arguments,
+        memory_config,
    )?;

    Ok(build)
 }

 /// Runs the standard JSON mode.
+#[allow(clippy::too_many_arguments)]
 pub fn standard_json<T: Compiler>(
    solc: &mut T,
    detect_missing_libraries: bool,
    base_path: Option<String>,
    include_paths: Vec<String>,
    allow_paths: Option<String>,
-    debug_config: revive_llvm_context::DebugConfig,
+    mut debug_config: revive_llvm_context::DebugConfig,
    llvm_arguments: &[String],
 ) -> anyhow::Result<()> {
    let solc_version = solc.version()?;
@@ -216,6 +228,9 @@ pub fn standard_json<T: Compiler>(
    let optimizer_settings =
        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;
+
    let include_metadata_hash = match solc_input.settings.metadata {
        Some(ref metadata) => metadata.bytecode_hash != Some(MetadataHash::None),
        None => true,
@@ -250,6 +265,7 @@ pub fn standard_json<T: Compiler>(
            include_metadata_hash,
            debug_config,
            llvm_arguments,
+            polkavm_settings.memory_config,
        )?;
        build.write_to_standard_json(&mut solc_output, &solc_version)?;
    }
@@ -277,6 +293,7 @@ pub fn combined_json<T: Compiler>(
    output_directory: Option<PathBuf>,
    overwrite: bool,
    llvm_arguments: &[String],
+    memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 ) -> anyhow::Result<()> {
    let build = standard_output(
        input_files,
@@ -293,6 +310,7 @@ pub fn combined_json<T: Compiler>(
        suppressed_warnings,
        debug_config,
        llvm_arguments,
+        memory_config,
    )?;

    let mut combined_json = solc.combined_json(input_files, format.as_str())?;
@@ -1,6 +1,7 @@
 //! Process for compiling a single compilation unit.
 //! The input data.

+use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory;
 use serde::Deserialize;
 use serde::Serialize;

@@ -22,6 +23,8 @@ pub struct Input {
    pub debug_config: revive_llvm_context::DebugConfig,
    /// The extra LLVM arguments give used for manual control.
    pub llvm_arguments: Vec<String>,
+    /// The PVM memory configuration.
+    pub memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
 }

 impl Input {
@@ -33,6 +36,7 @@ impl Input {
        optimizer_settings: revive_llvm_context::OptimizerSettings,
        debug_config: revive_llvm_context::DebugConfig,
        llvm_arguments: Vec<String>,
+        memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> Self {
        Self {
            contract,
@@ -41,6 +45,7 @@ impl Input {
            optimizer_settings,
            debug_config,
            llvm_arguments,
+            memory_config,
        }
    }
 }
@@ -50,6 +50,7 @@ pub trait Process {
            input.include_metadata_hash,
            input.debug_config,
            &input.llvm_arguments,
+            input.memory_config,
        );

        match result {
@@ -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)]
@@ -5,6 +5,7 @@ pub mod metadata;

 use std::collections::HashSet;

+use revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory;
 use serde::Deserialize;
 use serde::Serialize;
 use sha3::Digest;
@@ -78,6 +79,7 @@ impl Contract {
        include_metadata_hash: bool,
        debug_config: revive_llvm_context::DebugConfig,
        llvm_arguments: &[String],
+        memory_config: SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> anyhow::Result<ContractBuild> {
        let llvm = inkwell::context::Context::create();
        let optimizer = revive_llvm_context::Optimizer::new(optimizer_settings);
@@ -123,6 +125,7 @@ impl Contract {
            include_metadata_hash,
            debug_config,
            llvm_arguments,
+            memory_config,
        );
        context.set_solidity_data(revive_llvm_context::PolkaVMContextSolidityData::default());
        match self.ir {
@@ -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;

@@ -67,6 +68,7 @@ impl Project {
        include_metadata_hash: bool,
        debug_config: revive_llvm_context::DebugConfig,
        llvm_arguments: &[String],
+        memory_config: revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> anyhow::Result<Build> {
        let project = self.clone();
        #[cfg(feature = "parallel")]
@@ -83,6 +85,7 @@ impl Project {
                    optimizer_settings.clone(),
                    debug_config.clone(),
                    llvm_arguments.to_vec(),
+                    memory_config,
                );
                let process_output = {
                    #[cfg(target_os = "emscripten")]
@@ -319,6 +322,7 @@ impl revive_llvm_context::PolkaVMDependency for Project {
        include_metadata_hash: bool,
        debug_config: revive_llvm_context::DebugConfig,
        llvm_arguments: &[String],
+        memory_config: revive_solc_json_interface::SolcStandardJsonInputSettingsPolkaVMMemory,
    ) -> anyhow::Result<String> {
        let contract_path = project.resolve_path(identifier)?;
        let contract = project
@@ -339,6 +343,7 @@ impl revive_llvm_context::PolkaVMDependency for Project {
                include_metadata_hash,
                debug_config,
                llvm_arguments,
+                memory_config,
            )
            .map_err(|error| {
                anyhow::anyhow!(
@@ -167,9 +167,41 @@ pub struct Arguments {
    #[arg(long = "recursive-process-input")]
    pub recursive_process_input: Option<String>,

-    #[arg(long = "llvm-arg")]
    /// These are passed to LLVM as the command line to allow manual control.
+    #[arg(long = "llvm-arg")]
    pub llvm_arguments: Vec<String>,
+
+    /// The emulated EVM linear heap memory static buffer size in bytes.
+    ///
+    /// Unlike the EVM, due to the lack of dynamic memory metering, PVM contracts emulate
+    /// the EVM heap memory with a static buffer. Consequentially, instead of infinite
+    /// memory with exponentially growing gas costs, PVM contracts have a finite amount
+    /// of memory with constant gas costs available.
+    ///
+    /// If the contract uses more heap memory than configured, it will compile fine but
+    /// eventually revert execution at runtime!
+    ///
+    /// You are incentiviced to keep this value as small as possible:
+    /// 1.Increasing the heap size will increase startup costs.
+    /// 2.The heap size contributes to the total memory size a contract can use,
+    ///   which includes the contracts code size
+    #[arg(long = "heap-size")]
+    pub heap_size: Option<u32>,
+
+    /// The contracts total stack size in bytes.
+    ///
+    /// PVM is a register machine with a traditional stack memory space for local
+    /// variables. This controls the total amount of stack space the contract can use.
+    ///
+    /// If the contract uses more stack memory than configured, it will compile fine but
+    /// eventually revert execution at runtime!
+    ///
+    /// You are incentiviced to keep this value as small as possible:
+    /// 1.Increasing the heap size will increase startup costs.
+    /// 2.The stack size contributes to the total memory size a contract can use,
+    ///   which includes the contracts code size
+    #[arg(long = "stack-size")]
+    pub stack_size: Option<u32>,
 }

 impl Arguments {
@@ -298,6 +330,22 @@ impl Arguments {
            if self.metadata_hash.is_some() {
                anyhow::bail!("Metadata hash mode must specified in standard JSON input settings.");
            }
+
+            if self.heap_size.is_some() {
+                anyhow::bail!(
+                    "Heap size must be specified in standard JSON input polkavm memory settings."
+                );
+            }
+            if self.stack_size.is_some() {
+                anyhow::bail!(
+                    "Stack size must be specified in standard JSON input polkavm memory settings."
+                );
+            }
+            if self.emit_source_debug_info {
+                anyhow::bail!(
+                    "Debug info must be requested in standard JSON input polkavm settings."
+                );
+            }
        }

        Ok(())
@@ -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,8 +45,8 @@ fn main_inner() -> anyhow::Result<()> {
        writeln!(
            std::io::stdout(),
            ">={},<={}",
-            revive_solidity::SolcFirstSupportedVersion,
-            revive_solidity::SolcLastSupportedVersion,
+            resolc::SolcFirstSupportedVersion,
+            resolc::SolcLastSupportedVersion,
        )?;
        return Ok(());
    }
@@ -71,20 +71,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 +111,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()),
+            )?
        }
    };

@@ -129,7 +131,7 @@ fn main_inner() -> anyhow::Result<()> {

    let mut optimizer_settings = match arguments.optimization {
        Some(mode) => revive_llvm_context::OptimizerSettings::try_from_cli(mode)?,
-        None => revive_llvm_context::OptimizerSettings::cycles(),
+        None => revive_llvm_context::OptimizerSettings::size(),
    };
    if arguments.fallback_to_optimizing_for_size {
        optimizer_settings.enable_fallback_to_size();
@@ -148,25 +150,36 @@ 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 build = if arguments.yul {
-        revive_solidity::yul(
+        resolc::yul(
            input_files.as_slice(),
            &mut solc,
            optimizer_settings,
            include_metadata_hash,
            debug_config,
            &arguments.llvm_arguments,
+            memory_config,
        )
    } else if arguments.llvm_ir {
-        revive_solidity::llvm_ir(
+        resolc::llvm_ir(
            input_files.as_slice(),
            optimizer_settings,
            include_metadata_hash,
            debug_config,
            &arguments.llvm_arguments,
+            memory_config,
        )
    } else if arguments.standard_json {
-        revive_solidity::standard_json(
+        resolc::standard_json(
            &mut solc,
            arguments.detect_missing_libraries,
            arguments.base_path,
@@ -177,7 +190,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,
@@ -195,10 +208,11 @@ fn main_inner() -> anyhow::Result<()> {
            arguments.output_directory,
            arguments.overwrite,
            &arguments.llvm_arguments,
+            memory_config,
        )?;
        return Ok(());
    } else {
-        revive_solidity::standard_output(
+        resolc::standard_output(
            input_files.as_slice(),
            arguments.libraries,
            &mut solc,
@@ -213,6 +227,7 @@ fn main_inner() -> anyhow::Result<()> {
            suppressed_warnings,
            debug_config,
            &arguments.llvm_arguments,
+            memory_config,
        )
    }?;

@@ -19,7 +19,7 @@ use self::version::Version;
 pub const FIRST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 8, 0);

 /// The last supported version of `solc`.
-pub const LAST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 8, 29);
+pub const LAST_SUPPORTED_VERSION: semver::Version = semver::Version::new(0, 8, 30);

 /// `--include-path` was introduced in solc `0.8.8` <https://github.com/ethereum/solidity/releases/tag/v0.8.8>
 pub const FIRST_INCLUDE_PATH_VERSION: semver::Version = semver::Version::new(0, 8, 8);
@@ -92,26 +92,37 @@ pub fn build_solidity_with_options(
        SolcStandardJsonInputSettingsSelection::new_required(),
        SolcStandardJsonInputSettingsOptimizer::new(
            solc_optimizer_enabled,
-            None,
+            optimizer_settings.middle_end_as_string().chars().last(),
            &solc_version.default,
            false,
        ),
        None,
        None,
+        None,
    )?;

    let mut output = solc.standard_json(input, None, vec![], None)?;

+    let debug_config = revive_llvm_context::DebugConfig::new(
+        None,
+        optimizer_settings.middle_end_as_string() != "z",
+    );
+
    let project = Project::try_from_standard_json_output(
        &output,
        sources,
        libraries,
        &solc_version,
-        &DEBUG_CONFIG,
+        &debug_config,
    )?;

-    let build: crate::Build =
-        project.compile(optimizer_settings, false, DEBUG_CONFIG, Default::default())?;
+    let build: crate::Build = project.compile(
+        optimizer_settings,
+        false,
+        debug_config,
+        Default::default(),
+        Default::default(),
+    )?;
    build.write_to_standard_json(&mut output, &solc_version)?;

    Ok(output)
@@ -152,6 +163,7 @@ pub fn build_solidity_with_options_evm(
        ),
        None,
        None,
+        None,
    )?;

    let mut output = solc.standard_json(input, None, vec![], None)?;
@@ -203,6 +215,7 @@ pub fn build_solidity_and_detect_missing_libraries(
        SolcStandardJsonInputSettingsOptimizer::new(true, None, &solc_version.default, false),
        None,
        None,
+        None,
    )?;

    let mut output = solc.standard_json(input, None, vec![], None)?;
@@ -238,7 +251,13 @@ pub fn build_yul(source_code: &str) -> anyhow::Result<()> {
        source_code,
        None,
    )?;
-    let _build = project.compile(optimizer_settings, false, DEBUG_CONFIG, Default::default())?;
+    let _build = project.compile(
+        optimizer_settings,
+        false,
+        DEBUG_CONFIG,
+        Default::default(),
+        Default::default(),
+    )?;

    Ok(())
 }
@@ -270,6 +289,7 @@ pub fn check_solidity_warning(
        SolcStandardJsonInputSettingsOptimizer::new(true, None, &solc_version.default, false),
        None,
        suppressed_warnings,
+        None,
    )?;

    let output = solc.standard_json(input, None, vec![], None)?;
@@ -1,19 +1,33 @@
-import * as path from 'path';
+import * as path from 'path'

-const outputDir = 'artifacts';
-const binExtension = ':C.pvm';
-const asmExtension = ':C.pvmasm';
-const llvmExtension = '.ll';
-const contractSolFilename = 'contract.sol';
-const contractYulFilename = 'contract.yul';
-const contractOptimizedLLVMFilename = contractSolFilename + '.C.optimized';
-const contractUnoptimizedLLVMFilename = contractSolFilename + '.C.unoptimized';
-const pathToOutputDir = path.join(__dirname, '..', outputDir);
-const pathToContracts = path.join(__dirname, '..', 'src', 'contracts');
-const pathToBasicYulContract = path.join(pathToContracts, 'yul', contractYulFilename);
-const pathToBasicSolContract = path.join(pathToContracts, 'solidity', contractSolFilename);
-const pathToSolBinOutputFile = path.join(pathToOutputDir, contractSolFilename + binExtension);
-const pathToSolAsmOutputFile = path.join(pathToOutputDir, contractSolFilename + asmExtension);
+const outputDir = 'artifacts'
+const binExtension = ':C.pvm'
+const asmExtension = ':C.pvmasm'
+const llvmExtension = '.ll'
+const contractSolFilename = 'contract.sol'
+const contractYulFilename = 'contract.yul'
+const contractOptimizedLLVMFilename = contractSolFilename + '.C.optimized'
+const contractUnoptimizedLLVMFilename = contractSolFilename + '.C.unoptimized'
+const pathToOutputDir = path.join(__dirname, '..', outputDir)
+const pathToContracts = path.join(__dirname, '..', 'src', 'contracts')
+const pathToBasicYulContract = path.join(
+  pathToContracts,
+  'yul',
+  contractYulFilename
+)
+const pathToBasicSolContract = path.join(
+  pathToContracts,
+  'solidity',
+  contractSolFilename
+)
+const pathToSolBinOutputFile = path.join(
+  pathToOutputDir,
+  contractSolFilename + binExtension
+)
+const pathToSolAsmOutputFile = path.join(
+  pathToOutputDir,
+  contractSolFilename + asmExtension
+)

 export const paths = {
  outputDir: outputDir,
@@ -30,4 +44,4 @@ export const paths = {
  pathToBasicYulContract: pathToBasicYulContract,
  pathToSolBinOutputFile: pathToSolBinOutputFile,
  pathToSolAsmOutputFile: pathToSolAsmOutputFile,
-};
+}
@@ -0,0 +1,51 @@
+import * as shell from 'shelljs'
+import * as fs from 'fs'
+import { spawnSync } from 'child_process'
+
+interface CommandResult {
+  output: string
+  exitCode: number
+}
+
+export const executeCommand = (
+  command: string,
+  stdin?: string
+): CommandResult => {
+  if (stdin) {
+    const process = spawnSync(command, [], {
+      input: stdin,
+      shell: true,
+      encoding: 'utf8',
+      maxBuffer: 30 * 1024 * 1024,
+    })
+
+    return {
+      exitCode: process.status || 0,
+      output: (process.stdout || process.stderr || '').toString(),
+    }
+  }
+
+  const result = shell.exec(command, { silent: true, async: false })
+  return {
+    exitCode: result.code,
+    output: result.stdout || result.stderr || '',
+  }
+}
+
+export const isFolderExist = (folder: string): boolean => {
+  return shell.test('-d', folder)
+}
+
+export const isFileExist = (
+  pathToFileDir: string,
+  fileName: string,
+  fileExtension: string
+): boolean => {
+  return shell.ls(pathToFileDir).stdout.includes(fileName + fileExtension)
+}
+
+export const isFileEmpty = (file: string): boolean => {
+  if (fs.existsSync(file)) {
+    return fs.readFileSync(file).length === 0
+  }
+}
@@ -0,0 +1,44 @@
+import { executeCommand } from '../src/helper'
+import { paths } from '../src/entities'
+
+//id1746
+describe('Run with --asm by default', () => {
+  const command = `resolc ${paths.pathToBasicSolContract} --asm`
+  const result = executeCommand(command)
+  const commandInvalid = 'resolc --asm'
+  const resultInvalid = executeCommand(commandInvalid)
+
+  it('Valid command exit code = 0', () => {
+    expect(result.exitCode).toBe(0)
+  })
+
+  it('--asm output is presented', () => {
+    const expectedPatterns = [/(deploy)/i, /(call)/i, /(seal_return)/i]
+
+    for (const pattern of expectedPatterns) {
+      expect(result.output).toMatch(pattern)
+    }
+  })
+
+  it('solc exit code == resolc exit code', () => {
+    const command = `solc ${paths.pathToBasicSolContract} --asm`
+    const solcResult = executeCommand(command)
+    expect(solcResult.exitCode).toBe(result.exitCode)
+  })
+
+  it('run invalid: resolc --asm', () => {
+    expect(resultInvalid.output).toMatch(
+      /(No input sources specified|Compilation aborted)/i
+    )
+  })
+
+  it('Invalid command exit code = 1', () => {
+    expect(resultInvalid.exitCode).toBe(1)
+  })
+
+  it('Invalid solc exit code == Invalid resolc exit code', () => {
+    const command = 'solc --asm'
+    const solcResult = executeCommand(command)
+    expect(solcResult.exitCode).toBe(resultInvalid.exitCode)
+  })
+})
@@ -0,0 +1,241 @@
+import {
+  executeCommand,
+  isFolderExist,
+  isFileExist,
+  isFileEmpty,
+} from '../src/helper'
+import { paths } from '../src/entities'
+import * as shell from 'shelljs'
+import * as path from 'path'
+
+//id1762
+describe('Run resolc without any options', () => {
+  const command = 'resolc'
+  const result = executeCommand(command)
+
+  it('Info with help is presented', () => {
+    expect(result.output).toMatch(/(Usage: resolc)/i)
+  })
+
+  it('Exit code = 1', () => {
+    expect(result.exitCode).toBe(1)
+  })
+
+  it('solc exit code == resolc exit code', () => {
+    const command = 'solc'
+    const solcResult = executeCommand(command)
+    expect(solcResult.exitCode).toBe(result.exitCode)
+  })
+})
+
+//#1713
+describe('Default run a command from the help', () => {
+  const command = `resolc ${paths.pathToBasicSolContract} --overwrite -O3 --bin --output-dir "${paths.pathToOutputDir}"` // potential issue on resolc with full path on Windows cmd
+  const result = executeCommand(command)
+
+  it('Compiler run successful', () => {
+    expect(result.output).toMatch(/(Compiler run successful.)/i)
+  })
+  it('Exit code = 0', () => {
+    expect(result.exitCode).toBe(0)
+  })
+  it('Output dir is created', () => {
+    expect(isFolderExist(paths.pathToOutputDir)).toBe(true)
+  })
+  xit('Output file is created', () => {
+    // a bug on windows
+    expect(
+      isFileExist(
+        paths.pathToOutputDir,
+        paths.contractSolFilename,
+        paths.binExtension
+      )
+    ).toBe(true)
+  })
+  it('the output file is not empty', () => {
+    expect(isFileEmpty(paths.pathToSolBinOutputFile)).toBe(false)
+  })
+  it("No 'Error'/'Warning'/'Fail' in the output", () => {
+    expect(result.output).not.toMatch(/([Ee]rror|[Ww]arning|[Ff]ail)/i)
+  })
+})
+
+//#1818
+describe('Default run a command from the help', () => {
+  const command = `resolc ${paths.pathToBasicSolContract} --overwrite -O3 --bin --asm --output-dir "${paths.pathToOutputDir}"` // potential issue on resolc with full path on Windows cmd
+  const result = executeCommand(command)
+
+  it('Compiler run successful', () => {
+    expect(result.output).toMatch(/(Compiler run successful.)/i)
+  })
+  it('Exit code = 0', () => {
+    expect(result.exitCode).toBe(0)
+  })
+  it('Output dir is created', () => {
+    expect(isFolderExist(paths.pathToOutputDir)).toBe(true)
+  })
+  xit('Output files are created', () => {
+    // a bug on windows
+    expect(
+      isFileExist(
+        paths.pathToOutputDir,
+        paths.contractSolFilename,
+        paths.binExtension
+      )
+    ).toBe(true)
+    expect(
+      isFileExist(
+        paths.pathToOutputDir,
+        paths.contractSolFilename,
+        paths.asmExtension
+      )
+    ).toBe(true)
+  })
+  it('the output files are not empty', () => {
+    expect(isFileEmpty(paths.pathToSolBinOutputFile)).toBe(false)
+    expect(isFileEmpty(paths.pathToSolAsmOutputFile)).toBe(false)
+  })
+  it("No 'Error'/'Warning'/'Fail' in the output", () => {
+    expect(result.output).not.toMatch(/([Ee]rror|[Ww]arning|[Ff]ail)/i)
+  })
+})
+
+describe('Run resolc with source debug information', () => {
+  const commands = [
+    `resolc -g ${paths.pathToBasicSolContract} --overwrite --bin --asm --output-dir "${paths.pathToOutputDir}"`,
+    `resolc --disable-solc-optimizer -g ${paths.pathToBasicSolContract} --overwrite --bin --asm --output-dir "${paths.pathToOutputDir}"`,
+  ] // potential issue on resolc with full path on Windows cmd`;
+
+  for (var idx in commands) {
+    const command = commands[idx]
+    const result = executeCommand(command)
+
+    it('Compiler run successful', () => {
+      expect(result.output).toMatch(/(Compiler run successful.)/i)
+    })
+    it('Exit code = 0', () => {
+      expect(result.exitCode).toBe(0)
+    })
+    it('Output dir is created', () => {
+      expect(isFolderExist(paths.pathToOutputDir)).toBe(true)
+    })
+    it('Output files are created', () => {
+      // a bug on windows
+      expect(
+        isFileExist(
+          paths.pathToOutputDir,
+          paths.contractSolFilename,
+          paths.binExtension
+        )
+      ).toBe(true)
+      expect(
+        isFileExist(
+          paths.pathToOutputDir,
+          paths.contractSolFilename,
+          paths.asmExtension
+        )
+      ).toBe(true)
+    })
+    it('the output files are not empty', () => {
+      expect(isFileEmpty(paths.pathToSolBinOutputFile)).toBe(false)
+      expect(isFileEmpty(paths.pathToSolAsmOutputFile)).toBe(false)
+    })
+    it("No 'Error'/'Fail' in the output", () => {
+      expect(result.output).not.toMatch(/([Ee]rror|[Ff]ail)/i)
+    })
+  }
+})
+
+describe('Run resolc with source debug information, check LLVM debug-info', () => {
+  const commands = [
+    `resolc -g ${paths.pathToBasicSolContract} --overwrite --debug-output-dir="${paths.pathToOutputDir}"`,
+    `resolc -g --disable-solc-optimizer ${paths.pathToBasicSolContract} --overwrite --debug-output-dir="${paths.pathToOutputDir}"`,
+  ] // potential issue on resolc with full path on Windows cmd`;
+
+  for (var idx in commands) {
+    const command = commands[idx]
+    const result = executeCommand(command)
+
+    it('Compiler run successful', () => {
+      expect(result.output).toMatch(/(Compiler run successful.)/i)
+    })
+    it('Exit code = 0', () => {
+      expect(result.exitCode).toBe(0)
+    })
+    it('Output dir is created', () => {
+      expect(isFolderExist(paths.pathToOutputDir)).toBe(true)
+    })
+    it('Output files are created', () => {
+      // a bug on windows
+      expect(
+        isFileExist(
+          paths.pathToOutputDir,
+          paths.contractOptimizedLLVMFilename,
+          paths.llvmExtension
+        )
+      ).toBe(true)
+      expect(
+        isFileExist(
+          paths.pathToOutputDir,
+          paths.contractUnoptimizedLLVMFilename,
+          paths.llvmExtension
+        )
+      ).toBe(true)
+    })
+    it('the output files are not empty', () => {
+      expect(isFileEmpty(paths.pathToSolBinOutputFile)).toBe(false)
+      expect(isFileEmpty(paths.pathToSolAsmOutputFile)).toBe(false)
+    })
+    it("No 'Error'/'Fail' in the output", () => {
+      expect(result.output).not.toMatch(/([Ee]rror|[Ff]ail)/i)
+    })
+  }
+})
+
+describe('Standard JSON compilation with path options', () => {
+  const contractsDir = path.join(shell.tempdir(), 'contracts-test')
+  const inputFile = path.join(__dirname, '..', 'src/contracts/compiled/1.json')
+
+  beforeAll(() => {
+    shell.mkdir('-p', contractsDir)
+
+    const input = JSON.parse(shell.cat(inputFile).toString())
+
+    Object.entries(input.sources).forEach(
+      ([sourcePath, source]: [string, any]) => {
+        const filePath = path.join(contractsDir, sourcePath)
+        shell.mkdir('-p', path.dirname(filePath))
+        shell.ShellString(source.content).to(filePath)
+      }
+    )
+  })
+
+  afterAll(() => {
+    shell.rm('-rf', contractsDir)
+  })
+
+  describe('Output with all path options', () => {
+    let result: { exitCode: number; output: string }
+
+    beforeAll(() => {
+      const tempInputFile = path.join(contractsDir, 'temp-input.json')
+      shell.cp(inputFile, tempInputFile)
+      const inputContent = shell.cat(inputFile).toString()
+
+      const command = `resolc --standard-json --base-path "${contractsDir}" --include-path "${contractsDir}" --allow-paths "${contractsDir}"`
+
+      result = executeCommand(command, inputContent)
+
+      shell.rm(tempInputFile)
+    })
+
+    it('Compiler run successful without emiting warnings', () => {
+      const parsedResults = JSON.parse(result.output)
+      expect(
+        parsedResults.errors.filter(
+          (error: { type: string }) => error.type != 'Warning'
+        )
+      ).toEqual([])
+    })
+  })
+})
@@ -0,0 +1,39 @@
+import { executeCommand } from '../src/helper'
+import { paths } from '../src/entities'
+
+//id1743
+describe('Run with --yul by default', () => {
+  const command = `resolc ${paths.pathToBasicYulContract} --yul`
+  const result = executeCommand(command)
+  const commandInvalid = 'resolc --yul'
+  const resultInvalid = executeCommand(commandInvalid)
+
+  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)
+  })
+
+  xit('solc exit code == resolc exit code', () => {
+    // unknown solc issue for datatype of the contract
+    const command = `solc ${paths.pathToBasicSolContract} --yul`
+    const solcResult = executeCommand(command)
+    expect(solcResult.exitCode).toBe(result.exitCode)
+  })
+
+  it('run invalid: resolc --yul', () => {
+    expect(resultInvalid.output).toMatch(/(The input file is missing)/i)
+  })
+  it('Invalid command exit code = 1', () => {
+    expect(resultInvalid.exitCode).toBe(1)
+  })
+
+  it('Invalid solc exit code == Invalid resolc exit code', () => {
+    const command = 'solc --yul'
+    const solcResult = executeCommand(command)
+    expect(solcResult.exitCode).toBe(resultInvalid.exitCode)
+  })
+})
@@ -0,0 +1,188 @@
+import { executeCommand } from '../src/helper'
+import { paths } from '../src/entities'
+
+describe('Set of --combined-json tests', () => {
+  const zksolcCommand = 'zksolc'
+  const solcCommand = 'solc'
+  const json_args: string[] = [
+    `abi`,
+    `hashes`,
+    `metadata`,
+    `devdoc`,
+    `userdoc`,
+    `storage-layout`,
+    `ast`,
+    `asm`,
+    `bin`,
+    `bin-runtime`,
+  ]
+
+  //id1742:I
+  describe(`Run ${zksolcCommand} with just --combined-json`, () => {
+    const args = [`--combined-json`]
+    const result = executeCommand(zksolcCommand, args)
+
+    it('Valid command exit code = 1', () => {
+      expect(result.exitCode).toBe(1)
+    })
+
+    it('--combined-json error is presented', () => {
+      expect(result.output).toMatch(/(requires a value but none was supplied)/i)
+    })
+
+    it('solc exit code == zksolc exit code', () => {
+      const solcResult = executeCommand(solcCommand, args)
+      expect(solcResult.exitCode).toBe(result.exitCode)
+    })
+  })
+
+  //id1742:II
+  describe(`Run ${zksolcCommand} with Sol contract and --combined-json`, () => {
+    const args = [`${paths.pathToBasicSolContract}`, `--combined-json`]
+    const result = executeCommand(zksolcCommand, args)
+
+    it('Valid command exit code = 1', () => {
+      expect(result.exitCode).toBe(1)
+    })
+
+    it('--combined-json error is presented', () => {
+      expect(result.output).toMatch(/(requires a value but none was supplied)/i)
+    })
+
+    it('solc exit code == zksolc exit code', () => {
+      const solcResult = executeCommand(solcCommand, args)
+      expect(solcResult.exitCode).toBe(result.exitCode)
+    })
+  })
+
+  //id1742:III
+  for (let i = 0; i < json_args.length; i++) {
+    describe(`Run ${zksolcCommand} with Sol, --combined-json and ARG: ${json_args[i]}`, () => {
+      const args = [
+        `${paths.pathToBasicSolContract}`,
+        `--combined-json`,
+        `${json_args[i]}`,
+      ]
+      const result = executeCommand(zksolcCommand, args)
+
+      it('Valid command exit code = 0', () => {
+        expect(result.exitCode).toBe(0)
+      })
+
+      it('--combined-json error is presented', () => {
+        expect(result.output).toMatch(/(contracts)/i)
+      })
+
+      it('solc exit code == zksolc exit code', () => {
+        const solcResult = executeCommand(solcCommand, args)
+        expect(solcResult.exitCode).toBe(result.exitCode)
+      })
+    })
+  }
+
+  //id1829:I
+  for (let i = 0; i < json_args.length; i++) {
+    describe(`Run ${zksolcCommand} with Sol, --combined-json and wrong ARG: --${json_args[i]}`, () => {
+      const args = [
+        `${paths.pathToBasicSolContract}`,
+        `--combined-json`,
+        `--${json_args[i]}`,
+      ]
+      const result = executeCommand(zksolcCommand, args)
+
+      it('Valid command exit code = 1', () => {
+        expect(result.exitCode).toBe(1)
+      })
+
+      it('--combined-json error is presented', () => {
+        expect(result.output).toMatch(/(Invalid option|error)/i)
+      })
+
+      it('solc exit code == zksolc exit code', () => {
+        const solcResult = executeCommand(solcCommand, args)
+        expect(solcResult.exitCode).toBe(result.exitCode)
+      })
+    })
+  }
+
+  //id1829:II
+  for (let i = 0; i < json_args.length; i++) {
+    describe(`Run ${zksolcCommand} with Sol, --combined-json and multiple ARG: ${json_args[i]} ${json_args[i]}`, () => {
+      const args = [
+        `${paths.pathToBasicSolContract}`,
+        `--combined-json`,
+        `${json_args[i]}`,
+        `${json_args[i]}`,
+      ]
+      const result = executeCommand(zksolcCommand, args)
+
+      xit('Valid command exit code = 1', () => {
+        expect(result.exitCode).toBe(1)
+      })
+
+      it('--combined-json error is presented', () => {
+        expect(result.output).toMatch(
+          /(No such file or directory|cannot find the file specified)/i
+        ) // Hopefully we should have more precise message here!
+      })
+
+      xit('solc exit code == zksolc exit code', () => {
+        const solcResult = executeCommand(solcCommand, args)
+        expect(solcResult.exitCode).toBe(result.exitCode)
+      })
+    })
+  }
+
+  //id1829:III
+  for (let i = 0; i < json_args.length; i++) {
+    describe(`Run ${zksolcCommand} with Sol, and multiple (--combined-json ${json_args[i]})`, () => {
+      const args = [
+        `${paths.pathToBasicSolContract}`,
+        `--combined-json`,
+        `${json_args[i]}`,
+        `--combined-json`,
+        `${json_args[i]}`,
+      ]
+      const result = executeCommand(zksolcCommand, args)
+
+      it('Valid command exit code = 1', () => {
+        expect(result.exitCode).toBe(1)
+      })
+
+      it('--combined-json error is presented', () => {
+        expect(result.output).toMatch(/(cannot be used multiple times)/i)
+      })
+
+      it('solc exit code == zksolc exit code', () => {
+        const solcResult = executeCommand(solcCommand, args)
+        expect(solcResult.exitCode).toBe(result.exitCode)
+      })
+    })
+  }
+
+  //id1830
+  for (let i = 0; i < json_args.length; i++) {
+    describe(`Run ${zksolcCommand} with Yul, and --combined-json ${json_args[i]}`, () => {
+      const args = [
+        `${paths.pathToBasicYulContract}`,
+        `--combined-json`,
+        `${json_args[i]}`,
+      ]
+      const result = executeCommand(zksolcCommand, args)
+
+      it('Valid command exit code = 1', () => {
+        expect(result.exitCode).toBe(1)
+      })
+
+      it('--combined-json error is presented', () => {
+        expect(result.output).toMatch(/(ParserError: Expected identifier)/i)
+      })
+      asd
+
+      it('solc exit code == zksolc exit code', () => {
+        const solcResult = executeCommand(solcCommand, args)
+        expect(solcResult.exitCode).toBe(result.exitCode)
+      })
+    })
+  }
+})
@@ -10,12 +10,19 @@ description = "Execute revive contracts in a simulated blockchain runtime"
 [package.metadata.cargo-machete]
 ignored = ["codec", "scale-info"]

+[[bin]]
+name = "revive-runner"
+path = "src/main.rs"
+
 [features]
 std = ["polkadot-sdk/std"]
 default = ["solidity"]
-solidity = ["revive-solidity", "revive-differential"]
+solidity = ["resolc", "revive-differential", "revive-llvm-context"]

 [dependencies]
+env_logger = { workspace = true }
+clap = { workspace = true, features = ["help", "std", "derive"] }
+anyhow = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 hex = { workspace = true, features = ["serde"] }
@@ -32,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 }
+revive-llvm-context = { workspace = true, optional = true }
@@ -0,0 +1,26 @@
+# revive-runner
+
+The revive runner is a helper utility aiding in contract debugging.
+
+Given a PVM contract blob, it will upload, deploy and call that contract using a local, stand-alone un-blockchained pallet revive (which is our execution layer).
+
+This is somewhat similar to the geth `evm` utility binary.
+
+## Installation
+
+The `revive-runner` does not depend on the compiler itself, hence installing this utility does not depend on LLVM, so no LLVM build is required.
+
+Inside the root `revive` repository directory, execute:
+
+```bash
+make install-revive-runner
+```
+
+Which will install the `revive-runner` using `cargo`. 
+
+## Usage
+
+Set the `RUST_LOG` environment varibale to the `trace` level to see the full PolkaVM execution trace. For example:
+
+```bash
+RUST_LOG=trace revive-runner -f mycontract.pvm -c a9059cbb000000000000000000000000f24ff3a9cf04c71dbc94d0b566f7a27b94566cac0000000000000000000000000000000000000000000000000000000000000000
@@ -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),
@@ -0,0 +1,93 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+
+use revive_runner::{Code, OptionalHex, Specs, SpecsAction::*, TestAddress};
+
+/// Execute revive PolkaVM contracts locally.
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct Arguments {
+    /// The hex encoded calldata for the contract call.
+    #[arg(short, long)]
+    calldata: Option<String>,
+
+    /// The hex encoded calldata for the contract deployment.
+    #[arg(short, long)]
+    deploy_calldata: Option<String>,
+
+    /// The hex encoded contract code blob to instantiate and execute.
+    #[arg(short, long)]
+    blob: Option<String>,
+
+    /// The contract code to instantiate and execute.
+    #[arg(short, long)]
+    file: Option<PathBuf>,
+
+    /// The origin account used to initiate the deploy and call transactions.
+    #[arg(short, long)]
+    origin: Option<TestAddress>,
+
+    /// The value the call transaction is endowed with.
+    #[arg(short, long)]
+    value: Option<u128>,
+
+    /// The value the deploy transaction is endowed with.
+    #[arg(long)]
+    deploy_value: Option<u128>,
+}
+
+fn main() -> anyhow::Result<()> {
+    env_logger::init();
+
+    let arguments = Arguments::parse();
+
+    let code = match (arguments.blob, arguments.file) {
+        (Some(blob), None) => hex::decode(blob)
+            .map_err(|error| anyhow::anyhow!("expected hex encoded PVM blob: {error}"))?,
+        (None, Some(file)) => std::fs::read(&file).map_err(|error| {
+            anyhow::anyhow!("unable to read PVM file {}: {error}", file.display())
+        })?,
+        _ => anyhow::bail!("should either provide a PVM blob or a PVM file"),
+    };
+    let calldata = match arguments.calldata {
+        Some(calldata) => hex::decode(calldata)
+            .map_err(|error| anyhow::anyhow!("expected hex encoded calldata: {error}"))?,
+        None => vec![],
+    };
+    let deploy_calldata = match arguments.deploy_calldata {
+        Some(calldata) => hex::decode(calldata)
+            .map_err(|error| anyhow::anyhow!("expected hex encoded calldata: {error}"))?,
+        None => vec![],
+    };
+    let origin = arguments.origin.unwrap_or(TestAddress::Alice);
+
+    let actions = vec![
+        Instantiate {
+            origin: origin.clone(),
+            value: arguments.deploy_value.unwrap_or(0),
+            gas_limit: None,
+            storage_deposit_limit: None,
+            code: Code::Bytes(code),
+            data: deploy_calldata,
+            salt: OptionalHex::default(),
+        },
+        Call {
+            origin,
+            dest: TestAddress::Instantiated(0),
+            value: arguments.value.unwrap_or(0),
+            gas_limit: None,
+            storage_deposit_limit: None,
+            data: calldata,
+        },
+    ];
+
+    Specs {
+        actions,
+        differential: false,
+        ..Default::default()
+    }
+    .run();
+
+    Ok(())
+}
@@ -94,6 +94,12 @@ impl FindAuthor<<Runtime as frame_system::Config>::AccountId> for Runtime {
    where
        I: 'a + IntoIterator<Item = (frame_support::ConsensusEngineId, &'a [u8])>,
    {
-        Some([0xff; 32].into())
+        Some(
+            [[0xff; 20].as_slice(), [0xee; 12].as_slice()]
+                .concat()
+                .as_slice()
+                .try_into()
+                .unwrap(),
+        )
    }
 }
@@ -1,13 +1,15 @@
-use std::time::Instant;
+use std::{str::FromStr, time::Instant};

 use serde::{Deserialize, Serialize};

 use crate::*;
-use alloy_primitives::{keccak256, Address};
-#[cfg(feature = "revive-solidity")]
+use alloy_primitives::keccak256;
+#[cfg(feature = "resolc")]
+use alloy_primitives::Address;
+#[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 = "*/";
@@ -156,6 +158,39 @@ impl TestAddress {
    }
 }

+impl FromStr for TestAddress {
+    type Err = &'static str;
+
+    fn from_str(value: &str) -> Result<Self, Self::Err> {
+        value.try_into()
+    }
+}
+
+impl TryFrom<&str> for TestAddress {
+    type Error = &'static str;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "alice" => Ok(Self::Alice),
+            "bob" => Ok(Self::Bob),
+            "charlie" => Ok(Self::Charlie),
+            value => {
+                if let Ok(value) = value.parse() {
+                    return Ok(Self::Instantiated(value));
+                }
+
+                if let Ok(value) = hex::decode(value) {
+                    if value.len() == 20 {
+                        return Ok(Self::AccountId(H160(value.try_into().unwrap())));
+                    }
+                }
+
+                Err("can not parse into test address")
+            }
+        }
+    }
+}
+
 /// Specs for a contract test
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(default)]
@@ -212,6 +247,7 @@ impl Specs {
    /// Helper to allow not specifying the code bytes or path directly in the runner.json
    /// - Replace `Code::Bytes(bytes)` if `bytes` are empty: read `contract_file`
    /// - Replace `Code::Solidity{ path, ..}` if `path` is not provided: replace `path` with `contract_file`
+    #[allow(unused_variables)]
    pub fn replace_empty_code(&mut self, contract_name: &str, contract_path: &str) {
        for action in self.actions.iter_mut() {
            let code = match action {
@@ -220,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}"),
@@ -228,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,
            }
@@ -9,7 +9,7 @@ description = "Implements the low level runtime API bindings with pallet contrac

 [dependencies]
 anyhow = { workspace = true }
-inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-0"] }
+inkwell = { workspace = true, features = ["target-riscv", "no-libffi-linking", "llvm18-1"] }

 revive-common = { workspace = true }

@@ -5,34 +5,6 @@

 // Missing builtins

-#define EVM_WORD_SIZE 32
-#define ALIGN(size) ((size + EVM_WORD_SIZE - 1) & ~(EVM_WORD_SIZE - 1))
-#define MAX_MEMORY_SIZE (64 * 1024)
-char __memory[MAX_MEMORY_SIZE];
-uint32_t __memory_size = 0;
-
-void * __sbrk_internal(uint32_t offset, uint32_t size) {
-    if (offset >= MAX_MEMORY_SIZE || size > MAX_MEMORY_SIZE) {
-        POLKAVM_TRAP();
-    }
-
-    uint32_t new_size = ALIGN(offset + size);
-    if (new_size > MAX_MEMORY_SIZE) {
-        POLKAVM_TRAP();
-    }
-    if (new_size > __memory_size) {
-        __memory_size = new_size;
-    }
-
-    return (void *)&__memory[offset];
-}
-
-void * memset(void *b, int c, size_t len) {
-    uint8_t *dest = b;
-    while (len-- > 0) *dest++ = c;
-    return b;
-}
-
 void * memcpy(void *dst, const void *_src, size_t len) {
    uint8_t *dest = dst;
    const uint8_t *src = _src;
@@ -2,14 +2,6 @@ use inkwell::{context::Context, memory_buffer::MemoryBuffer, module::Module, sup

 include!(concat!(env!("OUT_DIR"), "/polkavm_imports.rs"));

-/// The emulated EVM heap memory global symbol.
-pub static MEMORY: &str = "__memory";
-
-/// The emulated EVM heap memory size global symbol.
-pub static MEMORY_SIZE: &str = "__memory_size";
-
-pub static SBRK: &str = "__sbrk_internal";
-
 pub static ADDRESS: &str = "address";

 pub static BALANCE: &str = "balance";
@@ -78,8 +70,7 @@ pub static WEIGHT_TO_FEE: &str = "weight_to_fee";

 /// All imported runtime API symbols.
 /// Useful for configuring common attributes and linkage.
-pub static IMPORTS: [&str; 34] = [
-    SBRK,
+pub static IMPORTS: [&str; 33] = [
    ADDRESS,
    BALANCE,
    BALANCE_OF,
@@ -8,6 +8,8 @@ pub use self::standard_json::input::language::Language as SolcStandardJsonInputL
 pub use self::standard_json::input::settings::metadata::Metadata as SolcStandardJsonInputSettingsMetadata;
 pub use self::standard_json::input::settings::metadata_hash::MetadataHash as SolcStandardJsonInputSettingsMetadataHash;
 pub use self::standard_json::input::settings::optimizer::Optimizer as SolcStandardJsonInputSettingsOptimizer;
+pub use self::standard_json::input::settings::polkavm::memory::MemoryConfig as SolcStandardJsonInputSettingsPolkaVMMemory;
+pub use self::standard_json::input::settings::polkavm::PolkaVM as SolcStandardJsonInputSettingsPolkaVM;
 pub use self::standard_json::input::settings::selection::file::flag::Flag as SolcStandardJsonInputSettingsSelectionFileFlag;
 pub use self::standard_json::input::settings::selection::file::File as SolcStandardJsonInputSettingsSelectionFile;
 pub use self::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
@@ -18,13 +18,14 @@ use crate::standard_json::input::settings::optimizer::Optimizer as SolcStandardJ
 use crate::standard_json::input::settings::selection::Selection as SolcStandardJsonInputSettingsSelection;
 #[cfg(feature = "resolc")]
 use crate::warning::Warning;
+use crate::SolcStandardJsonInputSettingsPolkaVM;

 use self::language::Language;
 use self::settings::Settings;
 use self::source::Source;

 /// The `solc --standard-json` input.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Input {
    /// The input language.
@@ -63,6 +64,7 @@ impl Input {
        optimizer: SolcStandardJsonInputSettingsOptimizer,
        metadata: Option<SolcStandardJsonInputSettingsMetadata>,
        #[cfg(feature = "resolc")] suppressed_warnings: Option<Vec<Warning>>,
+        polkavm: Option<SolcStandardJsonInputSettingsPolkaVM>,
    ) -> anyhow::Result<Self> {
        let mut paths: BTreeSet<PathBuf> = paths.iter().cloned().collect();
        let libraries = Settings::parse_libraries(library_map)?;
@@ -90,6 +92,7 @@ impl Input {
                output_selection,
                optimizer,
                metadata,
+                polkavm,
            ),
            #[cfg(feature = "resolc")]
            suppressed_warnings,
@@ -109,6 +112,7 @@ impl Input {
        optimizer: SolcStandardJsonInputSettingsOptimizer,
        metadata: Option<SolcStandardJsonInputSettingsMetadata>,
        suppressed_warnings: Option<Vec<Warning>>,
+        polkavm: Option<SolcStandardJsonInputSettingsPolkaVM>,
    ) -> anyhow::Result<Self> {
        #[cfg(feature = "parallel")]
        let iter = sources.into_par_iter(); // Parallel iterator
@@ -129,6 +133,7 @@ impl Input {
                output_selection,
                optimizer,
                metadata,
+                polkavm,
            ),
            suppressed_warnings,
        })
@@ -6,7 +6,7 @@ use serde::Serialize;
 use crate::standard_json::input::settings::metadata_hash::MetadataHash;

 /// The `solc --standard-json` input settings metadata.
-#[derive(Debug, Default, Serialize, Deserialize)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Metadata {
    /// The bytecode hash mode.
@@ -3,6 +3,7 @@
 pub mod metadata;
 pub mod metadata_hash;
 pub mod optimizer;
+pub mod polkavm;
 pub mod selection;

 use std::collections::BTreeMap;
@@ -13,10 +14,11 @@ use serde::Serialize;

 use self::metadata::Metadata;
 use self::optimizer::Optimizer;
+use self::polkavm::PolkaVM;
 use self::selection::Selection;

 /// The `solc --standard-json` input settings.
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Settings {
    /// The target EVM version.
@@ -43,6 +45,9 @@ pub struct Settings {
    /// The metadata settings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<Metadata>,
+    /// The resolc custom PolkaVM settings.
+    #[serde(skip_serializing)]
+    pub polkavm: Option<PolkaVM>,
 }

 impl Settings {
@@ -54,6 +59,7 @@ impl Settings {
        output_selection: Selection,
        optimizer: Optimizer,
        metadata: Option<Metadata>,
+        polkavm: Option<PolkaVM>,
    ) -> Self {
        Self {
            evm_version,
@@ -63,6 +69,7 @@ impl Settings {
            optimizer,
            metadata,
            via_ir: Some(true),
+            polkavm,
        }
    }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
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
xermicus	bb2f829361	expose custom PVM settings in the standard json interface (#318 ) Exposes the following PolkaVM specific options via the standard json interface: - Heap size - Stack size - Whether to emit source level debug information Additionally it is now forbidden to specify those as CLI option in standard JSON mode. They are bytecode altering options and having multiple ways to specify them creates unnecessary room for confusion: The standard JSON input description should be sufficient and succint for reproducible builds. Closes #290 --------- Signed-off-by: xermicus <bigcyrill@hotmail.com>	2025-05-13 15:19:00 +02:00
xermicus	1b8fcc4649	Update the Rust version (#316 ) - Update the Rust version to 1.85 - Update the package-lock.json - Update the musl-cross docker image --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-09 20:00:58 +02:00
Cyrill Leutwiler	0e9e405f21	remove any git dependencies Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-09 17:26:20 +02:00
xermicus	722dd86c27	remove STATUS.md (#315 ) This information is provided in the docs. Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-09 12:21:25 +02:00
PG Herveou	0421869e4b	Replace release 0.1.0-dev.15 with 0.1.0-dev.16 (#314 ) add missing patch and rename release	2025-05-08 15:26:10 +02:00
xermicus	32f55b976c	update changelog (#313 ) somehow went wrong Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-08 14:16:46 +02:00
PG Herveou	459a786299	v0.1.0-dev.15 release (#311 ) Co-authored-by: xermicus <cyrill@parity.io>	2025-05-08 14:09:55 +02:00
xermicus	fbaa45f283	support solc `v0.8.30` (#308 ) - Add support for solc `v0.8.30`. No changes in YUL or the binary interface. - Fix a semver bug in the NPM packages to correctly align their solc dependencies with our last supported version. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-08 13:29:13 +02:00
xermicus	f2fac85dae	add npm package information to release checklist (#312 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-08 13:14:28 +02:00
PG Herveou	b8f3073e29	Run lint:fix (#309 )	2025-05-08 12:36:11 +02:00
xermicus	11d47d74ac	apply size optimizations by default (#298 ) So far if no optimization level was specified, optimizations for execution time were applied. However, we currently are a bit limited on code size. Add to that, this setting is not available in solc and people generally ignore the docs, generating a lot of support requests. Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-07 15:35:48 +02:00
xermicus	e3a9c95d32	llvm-builder: use the ninja generator for building the builtins on windows (#299 ) The builtins build should use the Ninja generator (MSVC does not build a valid archive). Tested and verified here: https://github.com/paritytech/revive-alex-workflowtest/releases/tag/untagged-f02d0f574bab8404fead Closes #305 Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-05-07 11:10:58 +02:00
PG Herveou	a560b2d919	Fix npm-release job (#297 ) follow up from #295	2025-04-30 21:48:11 +02:00
PG Herveou	e07d0f0cb7	Move @parity/resolc from js-revive (#296 ) - Move npm package from paritytech/js-revive - Rename package to `@parity/resolc`	2025-04-30 17:24:52 +02:00
xermicus	f6a412eef4	release resolc v0.1.0-dev.14 (#289 ) Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-24 11:57:46 +02:00
xermicus	20e77cb0b5	configurable stack and heap memory size (#288 ) - Allow configuration of the maximum heap and stack size via CLI flags and JSON input settings. - Increase the default value for the stack size to 32kb. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-24 10:47:38 +02:00
xermicus	357bf58868	allow dynamic configuration of the heap memory (#287 ) This PR changes the implementation of the emulated EVM heap memory: Instead of linking in a C implementation the code is emitted directly into the contract module. Which allows making it configurable via a compiler parameter (a follow up PR to this). --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-23 20:25:55 +02:00
xermicus	f937188991	revive-runner: install with locked dependencies (#286 ) Make the installation of `revive-runner` easier: - Use locked dependencies to avoid issues with downstream crates - Make the llvm-context crate an optional dependency to the runner - Add it to the default `test` target ensuring that this actually works Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-22 19:46:18 +02:00
xermicus	6e44488b4f	revive-runner: add a utility binary for local contract execution (#284 ) I had this in mind for a while but never implemented a standalone binary so far because I always end up writing an integration test anyways. However, using a standalone version of the pallet based on the revive-runner crate is something people filing in bug reports do anyways, for example: https://github.com/paritytech/revive/issues/266 https://github.com/paritytech/contract-issues/issues/54 --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-22 15:34:51 +02:00
xermicus	5003f3e9ac	llvm-context: alloca at the function entry if possible (#283 ) Closes #48 Change the code size test to no longer emit debug info as to get a more accurate picture. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-15 15:22:24 +02:00
xermicus	431b5a2ce5	llvm-context: lazy handling of function arguments and immutable data (#282 ) - Lazily load function arguments so that they can be passed as pointers. - Lazily call the immutable store function to avoid storing zero sized immutable data. --------- Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>	2025-04-14 15:54:59 +02:00