added trace logging in EVM interpreter loop

.github/workflows/tests-misc.yml

@@ -370,6 +370,17 @@ jobs:
           components: cargo, clippy, rust-docs, rust-src, rustfmt, rustc, rust-std
       - name: Install protobuf
         run: brew install protobuf
+      - name: install solc
+        run: brew install solidity
+      - name: Install resolc
+        run: |
+          ASSET_URL="https://github.com/paritytech/revive/releases/download/v${{ inputs.version }}/resolc-universal-apple-darwin"
+          echo "Downloading resolc v${{ inputs.version }} from $ASSET_URL"
+          curl -Lsf --show-error -o /tmp/resolc "$ASSET_URL"
+          sudo cp /tmp/resolc /usr/local/bin/resolc
+          sudo chmod 755 /usr/local/bin/resolc
+        with:
+          version: 0.3.0        
       - name: cargo info
         run: |
           echo "######## rustup show ########"
@@ -406,3 +417,4 @@ jobs:
           else
             echo '### Good job! All the required jobs passed 🚀' >> $GITHUB_STEP_SUMMARY
           fi
+

cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs

@@ -1182,6 +1182,10 @@ impl pallet_revive::Config for Runtime {
 	type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>;
 	type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>;
 	type UnsafeUnstableInterface = ConstBool<false>;
+	#[cfg(feature = "runtime-benchmarks")]
+	type AllowEVMBytecode = ConstBool<true>;
+	#[cfg(not(feature = "runtime-benchmarks"))]
+	type AllowEVMBytecode = ConstBool<false>;
 	type UploadOrigin = EnsureSigned<Self::AccountId>;
 	type InstantiateOrigin = EnsureSigned<Self::AccountId>;
 	type RuntimeHoldReason = RuntimeHoldReason;
@@ -1199,7 +1203,10 @@ parameter_types! {
 impl pallet_migrations::Config for Runtime {
 	type RuntimeEvent = RuntimeEvent;
 	#[cfg(not(feature = "runtime-benchmarks"))]
-	type Migrations = pallet_revive::migrations::v1::Migration<Runtime>;
+	type Migrations = (
+		pallet_revive::migrations::v1::Migration<Runtime>,
+		pallet_revive::migrations::v2::Migration<Runtime>,
+	);
 	// Benchmarks need mocked migrations to guarantee that they succeed.
 	#[cfg(feature = "runtime-benchmarks")]
 	type Migrations = pallet_migrations::mock_helpers::MockedMigrations;

cumulus/parachains/runtimes/testing/penpal/src/lib.rs

@@ -853,6 +853,7 @@ impl pallet_revive::Config for Runtime {
 	type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>;
 	type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>;
 	type UnsafeUnstableInterface = ConstBool<true>;
+	type AllowEVMBytecode = ConstBool<true>;
 	type UploadOrigin = EnsureSigned<Self::AccountId>;
 	type InstantiateOrigin = EnsureSigned<Self::AccountId>;
 	type RuntimeHoldReason = RuntimeHoldReason;

prdoc/pr_9285.prdoc

@@ -0,0 +1,17 @@
+title: '[revive] revm backend'
+doc:
+- audience: Runtime Dev
+  description: |
+    Initial EVM support for pallet-revive via the REVM crate to create a dual-VM system that can execute both PolkaVM and EVM
+    - Added AllowEVMBytecode: Get<bool> to the config to enable/disable EVM call and instantiation
+    - The basic flow of uploading an EVM contract and running it should work
+    - instructions are copied and adapted from REVM they should be ignored in this PR and reviewed in follow-up PR
+crates:
+- name: pallet-revive
+  bump: major
+- name: pallet-revive-fixtures
+  bump: patch
+- name: asset-hub-westend-runtime
+  bump: patch
+- name: penpal-runtime
+  bump: patch

prdoc/pr_9385.prdoc

@@ -0,0 +1,35 @@
+title: Rve/revm instructions bitwise WIP
+doc:
+- audience: Runtime Dev
+  description: "\u2704 -----------------------------------------------------------------------------\n\
+    \nThank you for your Pull Request! \U0001F64F Please make sure it follows the\
+    \ contribution guidelines outlined in [this\ndocument](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md)\
+    \ and fill out the\nsections below. Once you're ready to submit your PR for review,\
+    \ please delete this section and leave only the text under\nthe \"Description\"\
+    \ heading.\n\n# Description\n\n*A concise description of what your PR is doing,\
+    \ and what potential issue it is solving. Use [Github semantic\nlinking](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword)\n\
+    to link the PR to an issue that must be closed once this is merged.*\n\n## Integration\n\
+    \n*In depth notes about how this PR should be integrated by downstream projects.\
+    \ This part is\nmandatory, and should be reviewed by reviewers, if the PR does\
+    \ NOT have the\n`R0-no-crate-publish-required` label. In case of a `R0-no-crate-publish-required`,\
+    \ it can be\nignored.*\n\n## Review Notes\n\n*In depth notes about the **implementation**\
+    \ details of your PR. This should be the main guide for reviewers to\nunderstand\
+    \ your approach and effectively review it. If too long, use\n[`<details>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details)*.\n\
+    \n*Imagine that someone who is depending on the old code wants to integrate your\
+    \ new code and the only information that\nthey get is this section. It helps to\
+    \ include example usage and default value here, with a `diff` code-block to show\n\
+    possibly integration.*\n\n*Include your leftover TODOs, if any, here.*\n\n# Checklist\n\
+    \n* [ ] My PR includes a detailed description as outlined in the \"Description\"\
+    \ and its two subsections above.\n* [ ] My PR follows the [labeling requirements](\n\
+    https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md#Process\n\
+    ) of this project (at minimum one label for `T` required)\n    * External contributors:\
+    \ ask maintainers to put the right label on your PR.\n* [ ] I have made corresponding\
+    \ changes to the documentation (if applicable)\n* [ ] I have added tests that\
+    \ prove my fix is effective or that my feature works (if applicable)\n\nYou can\
+    \ remove the \"Checklist\" section once all have been checked. Thank you for your\
+    \ contribution!\n\n\u2704 -----------------------------------------------------------------------------"
+crates:
+- name: pallet-revive-fixtures
+  bump: major
+- name: pallet-revive
+  bump: major

substrate/bin/node/runtime/src/lib.rs

@@ -1490,6 +1490,7 @@ impl pallet_revive::Config for Runtime {
 	type NativeToEthRatio = ConstU32<1_000_000>; // 10^(18 - 12) Eth is 10^18, Native is 10^12.
 	type EthGasEncoder = ();
 	type FindAuthor = <Runtime as pallet_authorship::Config>::FindAuthor;
+	type AllowEVMBytecode = ConstBool<true>;
 }
 
 impl pallet_sudo::Config for Runtime {

substrate/frame/revive/fixtures/build.rs

@@ -217,7 +217,7 @@ fn compile_with_standard_json(
 		"sources": {},
 		"settings": {
 			"optimizer": {
-				"enabled": true,
+				"enabled": false,
 				"runs": 200
 			},
 			"outputSelection":
@@ -344,12 +344,19 @@ fn compile_solidity_contracts(
 		return Ok(());
 	}
 
+	let evm_only = vec!["HostEvmOnly"];
+	let solidity_entries_pvm: Vec<_> = solidity_entries
+		.iter()
+		.cloned()
+		.filter(|entry| !evm_only.contains(&entry.path.file_stem().unwrap().to_str().unwrap()))
+		.collect();
+
 	// Compile with solc for EVM bytecode
 	let json = compile_with_standard_json("solc", contracts_dir, &solidity_entries)?;
 	extract_and_write_bytecode(&json, out_dir, ".sol.bin")?;
 
 	// Compile with resolc for PVM bytecode
-	let json = compile_with_standard_json("resolc", contracts_dir, &solidity_entries)?;
+	let json = compile_with_standard_json("resolc", contracts_dir, &solidity_entries_pvm)?;
 	extract_and_write_bytecode(&json, out_dir, ".resolc.polkavm")?;
 
 	Ok(())
@@ -463,7 +470,7 @@ fn generate_fixture_location(temp_dir: &Path, out_dir: &Path, entries: &[Entry])
 	// Generate sol! macros for Solidity contracts
 	for entry in entries.iter().filter(|e| matches!(e.contract_type, ContractType::Solidity)) {
 		let relative_path = format!("contracts/{}", entry.path().split('/').last().unwrap());
-		writeln!(file, r#"alloy_core::sol!("{}");"#, relative_path)
+		writeln!(file, r#"#[cfg(feature = "std")] alloy_core::sol!("{}");"#, relative_path)
 			.context("Failed to write sol! macro to fixture_location.rs")?;
 	}
 

substrate/frame/revive/fixtures/contracts/Arithmetic.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Arithmetic {
+    function testArithmetic() public {
+        // ADD tests
+        require(20 + 22 == 42, "ADD basic");
+
+        // SUB tests
+        require(42 - 20 == 22, "SUB basic");
+
+        // MUL tests
+        require(20 * 22 == 440, "MUL basic");
+
+        // DIV tests
+        require(100 / 5 == 20, "DIV basic");
+
+        // SDIV tests
+        require(int(-100) / 5 == -20, "SDIV neg/pos");
+        require(int(100) / -5 == -20, "SDIV pos/neg");
+        require(int(-100) / -5 == 20, "SDIV neg/neg");
+
+        // REM/MOD tests
+        require(100 % 7 == 2, "REM basic");
+
+        // SMOD tests
+        require(int(-100) % 7 == -2, "SMOD neg dividend");
+        require(int(100) % -7 == 2, "SMOD neg divisor");
+
+        // ADDMOD tests
+        require((10 + 15) % 7 == 4, "ADDMOD basic");
+
+        // MULMOD tests
+        require((10 * 15) % 7 == 3, "MULMOD basic");
+
+        // EXP tests
+        require(2 ** 3 == 8, "EXP basic");
+        require(10 ** 0 == 1, "EXP zero exponent");
+        require(0 ** 5 == 0, "EXP zero base");
+
+        // SIGNEXTEND tests
+        uint result1;
+        assembly {
+            result1 := signextend(0, 0xff)
+        }
+        require(result1 == type(uint256).max, "SIGNEXTEND negative byte");
+        uint result2;
+        assembly {
+            result2 := signextend(0, 0x7f)
+        }
+        require(result2 == 0x7f, "SIGNEXTEND positive byte");
+    }
+}

substrate/frame/revive/fixtures/contracts/Bitwise.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract Bitwise {
+    function testBitwise() public pure {
+        require(5 < 10, "LT basic");
+        require(type(uint256).max - 1 < type(uint256).max, "LT max");
+
+        require(10 > 5, "GT basic");
+        require(type(uint256).max > type(uint256).max - 1, "GT max");
+
+        require(5 != 10, "NEQ basic");
+        require(10 == 10, "EQ basic");
+        require(type(uint256).max == type(uint256).max, "EQ max");
+
+        require(int(-5) < int(10), "SLT basic");
+        require(type(int256).min < 0, "SLT min");
+
+        require(int(5) > int(-10), "SGT basic");
+        require(0 > type(int256).min, "SGT min");
+
+        require((5 & 3) == 1, "AND basic");
+        require((5 | 3) == 7, "OR basic");
+        require((5 ^ 3) == 6, "XOR basic");
+        require(~uint(0) == type(uint256).max, "NOT basic");
+
+        require((1 << 3) == 8, "SHL basic");
+        require((8 >> 3) == 1, "SHR basic");
+    }
+}

substrate/frame/revive/fixtures/contracts/Fibonacci.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Fibonacci {
+    function fib(uint n) public pure returns (uint) {
+        if (n <= 1) {
+            return n;
+        }
+        return fib(n - 1) + fib(n - 2);
+    }
+}

substrate/frame/revive/fixtures/contracts/Host.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+contract Host {
+    function balance(address account) public view returns (uint256) {
+        return account.balance;
+    }
+
+    function extcodesizeOp(address account) public view returns (uint256) {
+        uint256 size;
+        assembly {
+            size := extcodesize(account)
+        }
+        return size;
+    }
+
+    function extcodehashOp(address account) public view returns (bytes32) {
+        bytes32 hash;
+        assembly {
+            hash := extcodehash(account)
+        }
+        return hash;
+    }
+
+    function blockhashOp(uint256 blockNumber) public view returns (bytes32) {
+        bytes32 hash;
+        assembly {
+            hash := blockhash(blockNumber)
+        }
+        return hash;
+    }
+
+    function sloadOp(uint256 slot) public view returns (uint256) {
+        uint256 value;
+        assembly {
+            value := sload(slot)
+        }
+        return value;
+    }
+
+    function sstoreOp(uint256 slot, uint256 value) public {
+        assembly {
+            sstore(slot, value)
+        }
+    }
+
+    function log0Op(bytes32 data) public {
+        assembly {
+            log0(data, 0x20)
+        }
+    }
+
+    function log1Op(bytes32 data, bytes32 topic1) public {
+        assembly {
+            log1(data, 0x20, topic1)
+        }
+    }
+
+    function log2Op(bytes32 data, bytes32 topic1, bytes32 topic2) public {
+        assembly {
+            log2(data, 0x20, topic1, topic2)
+        }
+    }
+
+    function log3Op(
+        bytes32 data,
+        bytes32 topic1,
+        bytes32 topic2,
+        bytes32 topic3
+    ) public {
+        assembly {
+            log3(data, 0x20, topic1, topic2, topic3)
+        }
+    }
+
+    function log4Op(
+        bytes32 data,
+        bytes32 topic1,
+        bytes32 topic2,
+        bytes32 topic3,
+        bytes32 topic4
+    ) public {
+        assembly {
+            log4(data, 0x20, topic1, topic2, topic3, topic4)
+        }
+    }
+
+    function selfbalance() public view returns (uint256) {
+        return address(this).balance;
+    }
+}

substrate/frame/revive/fixtures/contracts/HostEvmOnly.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract HostEvmOnly {
+    function selfdestructOp(address payable recipient) public {
+        assembly {
+            selfdestruct(recipient)
+        }
+    }
+    function extcodecopyOp(
+        address account,
+        uint256 offset,
+        uint256 size
+    ) public view returns (bytes memory code) {
+        code = new bytes(size);
+        assembly {
+            extcodecopy(account, add(code, 32), offset, size)
+        }
+    }
+}

substrate/frame/revive/fixtures/contracts/HostTransientMemory.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+contract HostTransientMemory {
+    function transientMemoryTest(
+        uint256 slot,
+        uint256 a
+    ) public returns (uint256) {
+        uint256 value;
+        assembly {
+            tstore(slot, a)
+        }
+        value = 1;
+        assembly {
+            value := tload(slot)
+        }
+        return value - a;
+    }
+}