pre-release v0.1.0-dev.5 (#110)

Rename the revive metadata fields and includes the commit hash and LLVM version in the revive version (similar to what solc does).

Signed-off-by: xermicus <cyrill@parity.io>

CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+## Unreleased
+
+## v0.1.0-dev.5
+
+This is development pre-release.
+
+# Added
+- Implement the `CODESIZE` and `EXTCODESIZE` opcodes.
+
+# Changed
+- Include the full revive version in the contract metadata.
+
+# Fixed
+
+## v0.1.0-dev-4
+
+This is development pre-release.
+
+# Added
+- Support the `ORIGIN` opcode.
+
+# Changed
+- Update polkavm to `v0.14.0`.
+- Enable the `a`, `fast-unaligned-access` and `xtheadcondmov` LLVM target features, decreasing the code size for some contracts.
+
+# Fixed

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.1.0-dev.5"
 authors = [
     "Cyrill Leutwiler <cyrill@parity.io>",
     "Parity Technologies <admin@parity.io>",
@@ -14,18 +14,18 @@ repository = "https://github.com/paritytech/revive"
 rust-version = "1.80.0"
 
 [workspace.dependencies]
-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-solidity = { version = "0.1.0", path = "crates/solidity" }
-revive-stdlib = { version = "0.1.0", path = "crates/stdlib" }
+revive-benchmarks = { version = "0.1.0-dev.5", path = "crates/benchmarks" }
+revive-builtins = { version = "0.1.0-dev.5", path = "crates/builtins" }
+revive-common = { version = "0.1.0-dev.5", path = "crates/common" }
+revive-differential = { version = "0.1.0-dev.5", path = "crates/differential" }
+revive-integration = { version = "0.1.0-dev.5", path = "crates/integration" }
+revive-linker = { version = "0.1.0-dev.5", path = "crates/linker" }
+lld-sys = { version = "0.1.0-dev.5", path = "crates/lld-sys" }
+revive-llvm-context = { version = "0.1.0-dev.5", path = "crates/llvm-context" }
+revive-runtime-api = { version = "0.1.0-dev.5", path = "crates/runtime-api" }
+revive-runner = { version = "0.1.0-dev.5", path = "crates/runner" }
+revive-solidity = { version = "0.1.0-dev.5", path = "crates/solidity" }
+revive-stdlib = { version = "0.1.0-dev.5", path = "crates/stdlib" }
 
 hex = "0.4"
 petgraph = "0.6"
@@ -51,10 +51,10 @@ path-slash = "0.2"
 rayon = "1.8"
 clap = { version = "4", default-features = false, features = ["derive"] }
 rand = "0.8"
-polkavm-common = "0.13"
-polkavm-linker = "0.13"
-polkavm-disassembler = "0.13"
-polkavm = "0.13"
+polkavm-common = "0.14"
+polkavm-linker = "0.14"
+polkavm-disassembler = "0.14"
+polkavm = "0.14"
 alloy-primitives = { version = "0.8", features = ["serde"] }
 alloy-sol-types = "0.8"
 alloy-genesis = "0.3"
@@ -67,11 +67,12 @@ log = { version = "0.4" }
 # polkadot-sdk and friends
 codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
 scale-info = { version = "2.11.1", default-features = false }
-polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "aeebf2f383390f2f86527d70212162d5dbea8b93" }
+polkadot-sdk = { git = "https://github.com/paritytech/polkadot-sdk", rev = "2b6b69641ccff4d7aa9c32051bbb2f1e775ef8cc" }
 
 # llvm
 [workspace.dependencies.inkwell]
-version = "0.5"
+git = "https://github.com/TheDan64/inkwell.git"
+rev = "7b410298b6a93450adaa90b1841d5805a3038f12"
 default-features = false
 features = ["serde", "llvm18-0", "no-libffi-linking", "target-riscv"]
 

RELEASE.md

@@ -0,0 +1,11 @@
+# Release checklist
+
+Prior to the first stable release we neither have formal release processes nor do we follow a fixed release schedule.
+
+To create a new pre-release:
+
+1. Merge a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly
+2. Push a release tag to `main`
+3. Manually trigger the `Build revive-debian` action
+4. Create a __pre-release__ from the tag and manually upload the build artifact generated by the action
+5. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly

crates/integration/codesize.json

@@ -1,10 +1,10 @@
 {
-  "Baseline": 989,
-  "Computation": 4153,
-  "DivisionArithmetics": 40614,
-  "ERC20": 47343,
-  "Events": 1781,
-  "FibonacciIterative": 3035,
-  "Flipper": 3393,
-  "SHA1": 33553
+  "Baseline": 967,
+  "Computation": 4022,
+  "DivisionArithmetics": 31787,
+  "ERC20": 44233,
+  "Events": 1743,
+  "FibonacciIterative": 2927,
+  "Flipper": 3408,
+  "SHA1": 26009
 }

crates/integration/contracts/ERC20.sol

@@ -4,9 +4,25 @@ pragma solidity ^0.8;
 
 /* runner.json
 {
+    "differential": true,
     "actions": [
         {
-      "Instantiate": {}
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "ERC20"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "ERC20Tester"
+                    }
+                }
+            }
         }
     ]
 }
@@ -82,3 +98,26 @@ contract ERC20 is IERC20 {
         emit Transfer(msg.sender, address(0), amount);
     }
 }
+
+contract ERC20Tester {
+    constructor() {
+        address BOB = address(0xffffffffffffffffffffffffffffffffffffff);
+        ERC20 token = new ERC20();
+        assert(token.decimals() == 18);
+
+        token.mint(300);
+        assert(token.balanceOf(address(this)) == 300);
+        token.transfer(BOB, 100);
+        assert(token.balanceOf(address(this)) == 200);
+        assert(token.balanceOf(BOB) == 100);
+
+        token.approve(address(this), 100);
+
+        token.transferFrom(address(this), BOB, 100);
+        assert(token.balanceOf(BOB) == 200);
+        assert(token.balanceOf(address(this)) == 100);
+
+        token.burn(100);
+        assert(token.balanceOf(address(this)) == 0);
+    }
+}

crates/integration/contracts/Storage.sol

@@ -22,6 +22,14 @@ pragma solidity ^0.8;
                 },
                 "data": "fabc9efaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
             }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "558b9f9bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+            }
         }
     ]
 }
@@ -30,10 +38,18 @@ pragma solidity ^0.8;
 contract Storage {
     function transient(uint value) public returns (uint ret) {
         assembly {
-            let slot := 123
+            let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
             tstore(slot, value)
             let success := call(0, 0, 0, 0, 0, 0, 0)
             ret := tload(slot)
         }
     }
+
+    function persistent(uint value) public returns (uint ret) {
+        assembly {
+            let slot := 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
+            sstore(slot, value)
+            ret := sload(slot)
+        }
+    }
 }

crates/integration/contracts/Transaction.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/* runner.json
+{
+    "differential": true,
+    "actions": [
+        {
+            "Upload": {
+                "code": {
+                    "Solidity": {
+                        "contract": "TransactionOrigin"
+                    }
+                }
+            }
+        },
+        {
+            "Instantiate": {
+                "code": {
+                    "Solidity": {
+                        "contract": "TransactionTester"
+                    }
+                }
+            }
+        },
+        {
+            "Call": {
+                "dest": {
+                    "Instantiated": 0
+                },
+                "data": "f8a8fd6d"
+            }
+        }
+    ]
+}
+*/
+
+contract TransactionTester {
+    constructor() payable {
+        assert(tx.origin == new TransactionOrigin().test());
+    }
+
+    function test() public payable returns (address ret) {
+        ret = tx.origin;
+    }
+}
+
+contract TransactionOrigin {
+    function test() public payable returns (address ret) {
+        assert(msg.sender != tx.origin);
+
+        ret = tx.origin;
+    }
+}

crates/integration/src/tests.rs

@@ -43,6 +43,7 @@ test_spec!(call, "Caller", "Call.sol");
 test_spec!(transfer, "Transfer", "Transfer.sol");
 test_spec!(return_data_oob, "ReturnDataOob", "ReturnDataOob.sol");
 test_spec!(immutables, "Immutables", "Immutables.sol");
+test_spec!(transaction, "Transaction", "Transaction.sol");
 
 fn instantiate(path: &str, contract: &str) -> Vec<SpecsAction> {
     vec![Instantiate {
@@ -320,6 +321,114 @@ fn ext_code_hash() {
     .run();
 }
 
+#[test]
+fn ext_code_size() {
+    let alice = Address::from(ALICE.0);
+    let own_address = alice.create(0);
+    let baseline_address = alice.create2([0u8; 32], keccak256(Contract::baseline().pvm_runtime));
+
+    let own_code_size = U256::from(
+        Contract::ext_code_size(Default::default())
+            .pvm_runtime
+            .len(),
+    );
+    let baseline_code_size = U256::from(Contract::baseline().pvm_runtime.len());
+
+    Specs {
+        actions: vec![
+            // Instantiate the test contract
+            instantiate("contracts/ExtCode.sol", "ExtCode").remove(0),
+            // Instantiate the baseline contract
+            Instantiate {
+                origin: TestAddress::Alice,
+                value: 0,
+                gas_limit: Some(GAS_LIMIT),
+                storage_deposit_limit: None,
+                code: Code::Solidity {
+                    path: Some("contracts/Baseline.sol".into()),
+                    contract: "Baseline".to_string(),
+                    solc_optimizer: None,
+                    pipeline: None,
+                },
+                data: vec![],
+                salt: OptionalHex::from([0; 32]),
+            },
+            // Alice is not a contract and returns a code size of 0
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(alice).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from([0u8; 32].to_vec()),
+                gas_consumed: None,
+            }),
+            // Unknown address returns a code size of 0
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(Address::from([0xff; 20])).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from([0u8; 32].to_vec()),
+                gas_consumed: None,
+            }),
+            // Own address via extcodesize returns own code size
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(own_address).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from(own_code_size.to_be_bytes::<32>().to_vec()),
+                gas_consumed: None,
+            }),
+            // Own address via codesize returns own code size
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::code_size().calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from(own_code_size.to_be_bytes::<32>().to_vec()),
+                gas_consumed: None,
+            }),
+            // Baseline address returns the baseline code size
+            Call {
+                origin: TestAddress::Alice,
+                dest: TestAddress::Instantiated(0),
+                value: 0,
+                gas_limit: None,
+                storage_deposit_limit: None,
+                data: Contract::ext_code_size(baseline_address).calldata,
+            },
+            VerifyCall(VerifyCallExpectation {
+                success: true,
+                output: OptionalHex::from(baseline_code_size.to_be_bytes::<32>().to_vec()),
+                gas_consumed: None,
+            }),
+        ],
+        ..Default::default()
+    }
+    .run();
+}
+
 /*
 // These test were implement for the mock-runtime and need to be ported yet.
 
@@ -348,28 +457,4 @@ fn create2_failure() {
 
     assert_eq!(output.flags, ReturnFlags::Revert);
 }
-
-#[test]
-fn ext_code_size() {
-    let contract = Contract::ext_code_size(Transaction::default_address());
-    let (_, output) = assert_success(&contract, false);
-    let received = U256::from_be_slice(&output.data);
-    let expected = U256::from(contract.pvm_runtime.len());
-    assert_eq!(received, expected);
-
-    let contract = Contract::ext_code_size(Default::default());
-    let (_, output) = assert_success(&contract, false);
-    let received = U256::from_be_slice(&output.data);
-    let expected = U256::ZERO;
-    assert_eq!(received, expected);
-}
-
-#[test]
-fn code_size() {
-    let contract = Contract::code_size();
-    let (_, output) = assert_success(&contract, false);
-    let expected = U256::from(contract.pvm_runtime.len());
-    let received = U256::from_be_slice(&output.data);
-    assert_eq!(expected, received);
-}
 */

crates/llvm-context/src/polkavm/context/function/runtime/entry.rs

@@ -27,18 +27,6 @@ impl Entry {
     where
         D: Dependency + Clone,
     {
-        context.declare_global(
-            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER,
-            context.word_type().array_type(0),
-            AddressSpace::Stack,
-        );
-
-        context.declare_global(
-            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE,
-            context.xlen_type(),
-            AddressSpace::Stack,
-        );
-
         let calldata_type = context.array_type(context.byte_type(), Self::MAX_CALLDATA_SIZE);
         context.set_global(
             crate::polkavm::GLOBAL_CALLDATA_POINTER,
@@ -195,6 +183,18 @@ where
             Some(inkwell::module::Linkage::External),
         )?;
 
+        context.declare_global(
+            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_POINTER,
+            context.word_type().array_type(0),
+            AddressSpace::Stack,
+        );
+
+        context.declare_global(
+            revive_runtime_api::immutable_data::GLOBAL_IMMUTABLE_DATA_SIZE,
+            context.xlen_type(),
+            AddressSpace::Stack,
+        );
+
         Ok(())
     }
 

crates/llvm-context/src/polkavm/context/mod.rs

@@ -669,22 +669,10 @@ where
                 self.build_byte_swap(value)
             }
             AddressSpace::Storage | AddressSpace::TransientStorage => {
-                let storage_key_value = self.builder().build_ptr_to_int(
-                    pointer.value,
-                    self.word_type(),
-                    "storage_ptr_to_int",
-                )?;
-                let storage_key_pointer = self.build_alloca(self.word_type(), "storage_key");
-                let storage_key_pointer_casted = self.builder().build_ptr_to_int(
-                    storage_key_pointer.value,
-                    self.xlen_type(),
-                    "storage_key_pointer_casted",
-                )?;
-                self.builder()
-                    .build_store(storage_key_pointer.value, storage_key_value)?;
-
                 let storage_value_pointer =
                     self.build_alloca(self.word_type(), "storage_value_pointer");
+                self.build_store(storage_value_pointer, self.word_const(0))?;
+
                 let storage_value_length_pointer =
                     self.build_alloca(self.xlen_type(), "storage_value_length_pointer");
                 self.build_store(
@@ -698,7 +686,7 @@ where
                     revive_runtime_api::polkavm_imports::GET_STORAGE,
                     &[
                         self.xlen_type().const_int(transient as u64, false).into(),
-                        storage_key_pointer_casted.into(),
+                        pointer.to_int(self).into(),
                         self.xlen_type().const_all_ones().into(),
                         storage_value_pointer.to_int(self).into(),
                         storage_value_length_pointer.to_int(self).into(),
@@ -767,18 +755,6 @@ where
                     self.word_type().as_basic_type_enum()
                 );
 
-                let storage_key_value = self.builder().build_ptr_to_int(
-                    pointer.value,
-                    self.word_type(),
-                    "storage_ptr_to_int",
-                )?;
-                let storage_key_pointer = self.build_alloca(self.word_type(), "storage_key");
-                let storage_key_pointer_casted = self.builder().build_ptr_to_int(
-                    storage_key_pointer.value,
-                    self.xlen_type(),
-                    "storage_key_pointer_casted",
-                )?;
-
                 let storage_value_pointer = self.build_alloca(self.word_type(), "storage_value");
                 let storage_value_pointer_casted = self.builder().build_ptr_to_int(
                     storage_value_pointer.value,
@@ -786,8 +762,6 @@ where
                     "storage_value_pointer_casted",
                 )?;
 
-                self.builder()
-                    .build_store(storage_key_pointer.value, storage_key_value)?;
                 self.builder()
                     .build_store(storage_value_pointer.value, value)?;
 
@@ -797,7 +771,7 @@ where
                     revive_runtime_api::polkavm_imports::SET_STORAGE,
                     &[
                         self.xlen_type().const_int(transient as u64, false).into(),
-                        storage_key_pointer_casted.into(),
+                        pointer.to_int(self).into(),
                         self.xlen_type().const_all_ones().into(),
                         storage_value_pointer_casted.into(),
                         self.integer_const(crate::polkavm::XLEN, 32).into(),

crates/llvm-context/src/polkavm/evm/context.rs

@@ -27,12 +27,19 @@ where
 
 /// Translates the `tx.origin` instruction.
 pub fn origin<'ctx, D>(
-    _context: &mut Context<'ctx, D>,
+    context: &mut Context<'ctx, D>,
 ) -> anyhow::Result<inkwell::values::BasicValueEnum<'ctx>>
 where
     D: Dependency + Clone,
 {
-    todo!()
+    let address_type = context.integer_type(revive_common::BIT_LENGTH_ETH_ADDRESS);
+    let address_pointer = context.build_alloca_at_entry(address_type, "origin_address");
+    context.build_store(address_pointer, address_type.const_zero())?;
+    context.build_runtime_call(
+        revive_runtime_api::polkavm_imports::ORIGIN,
+        &[address_pointer.to_int(context).into()],
+    );
+    context.build_load_address(address_pointer)
 }
 
 /// Translates the `chain_id` instruction.

crates/llvm-context/src/polkavm/evm/ext_code.rs

@@ -1,7 +1,5 @@
 //! Translates the external code operations.
 
-use inkwell::values::BasicValue;
-
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 
@@ -14,37 +12,23 @@ pub fn size<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let address_pointer = match address {
-        Some(address) => {
-            let address_pointer = context.build_alloca(context.word_type(), "value");
-            context.build_store(address_pointer, address)?;
-            address_pointer
-        }
-        None => context.sentinel_pointer(),
+    let address = match address {
+        Some(address) => address,
+        None => super::context::address(context)?.into_int_value(),
     };
 
-    let address_pointer_casted = context.builder().build_ptr_to_int(
-        address_pointer.value,
-        context.xlen_type(),
-        "address_pointer",
-    )?;
-    let value = context
-        .build_runtime_call(
-            revive_runtime_api::polkavm_imports::CODE_SIZE,
-            &[address_pointer_casted.into()],
-        )
-        .unwrap_or_else(|| {
-            panic!(
-                "{} should return a value",
-                revive_runtime_api::polkavm_imports::CODE_SIZE
-            )
-        })
-        .into_int_value();
+    let address_pointer = context.build_address_argument_store(address)?;
+    let output_pointer = context.build_alloca_at_entry(context.word_type(), "output_pointer");
 
-    Ok(context
-        .builder()
-        .build_int_z_extend(value, context.word_type(), "extcodesize")?
-        .as_basic_value_enum())
+    context.build_runtime_call(
+        revive_runtime_api::polkavm_imports::CODE_SIZE,
+        &[
+            address_pointer.to_int(context).into(),
+            output_pointer.to_int(context).into(),
+        ],
+    );
+
+    context.build_load(output_pointer, "code_size")
 }
 
 /// Translates the `extcodehash` instruction.

crates/llvm-context/src/polkavm/evm/storage.rs

@@ -1,7 +1,6 @@
 //! Translates the storage operations.
 
 use crate::polkavm::context::address_space::AddressSpace;
-use crate::polkavm::context::pointer::Pointer;
 use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 
@@ -13,14 +12,10 @@ pub fn load<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::Storage,
-        context.word_type(),
-        position,
-        "storage_load_position_pointer",
-    );
-    context.build_load(position_pointer, "storage_load_value")
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::Storage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_load(slot_ptr, "storage_load_value")
 }
 
 /// Translates the storage store.
@@ -32,14 +27,10 @@ pub fn store<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::Storage,
-        context.word_type(),
-        position,
-        "storage_store_position_pointer",
-    );
-    context.build_store(position_pointer, value)?;
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::Storage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_store(slot_ptr, value)?;
     Ok(())
 }
 
@@ -51,14 +42,10 @@ pub fn transient_load<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::TransientStorage,
-        context.word_type(),
-        position,
-        "transient_storage_load_position_pointer",
-    );
-    context.build_load(position_pointer, "transient_storage_load_value")
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::TransientStorage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_load(slot_ptr, "transient_storage_load_value")
 }
 
 /// Translates the transient storage store.
@@ -70,13 +57,9 @@ pub fn transient_store<'ctx, D>(
 where
     D: Dependency + Clone,
 {
-    let position_pointer = Pointer::new_with_offset(
-        context,
-        AddressSpace::TransientStorage,
-        context.word_type(),
-        position,
-        "transient_storage_store_position_pointer",
-    );
-    context.build_store(position_pointer, value)?;
+    let mut slot_ptr = context.build_alloca_at_entry(context.word_type(), "slot_pointer");
+    slot_ptr.address_space = AddressSpace::TransientStorage;
+    context.builder().build_store(slot_ptr.value, position)?;
+    context.build_store(slot_ptr, value)?;
     Ok(())
 }

crates/llvm-context/src/target_machine/mod.rs

@@ -39,9 +39,9 @@ impl TargetMachine {
 
     /// LLVM target features.
     #[cfg(feature = "riscv-zbb")]
-    pub const VM_FEATURES: &'static str = "+zbb,+e,+m,+c";
+    pub const VM_FEATURES: &'static str = "+zbb,+a,+e,+m,+c,+fast-unaligned-access,+xtheadcondmov";
     #[cfg(not(feature = "riscv-zbb"))]
-    pub const VM_FEATURES: &'static str = "+e,+m,+c";
+    pub const VM_FEATURES: &'static str = "+a,+e,+m,+c,+fast-unaligned-access,+xtheadcondmov";
 
     /// A shortcut constructor.
     /// A separate instance for every optimization level is created.

crates/runner/src/lib.rs

@@ -72,7 +72,7 @@ impl ExtBuilder {
         Self {
             balance_genesis_config: value
                 .iter()
-                .map(|(address, balance)| (AccountId::to_account_id(address), *balance))
+                .map(|(address, balance)| (AccountId::to_fallback_account_id(address), *balance))
                 .collect(),
         }
     }
@@ -246,7 +246,7 @@ pub enum Code {
     /// A contract blob
     Bytes(Vec<u8>),
     /// Pre-existing contract hash
-    Hash(Hash),
+    Hash(crate::runtime::Hash),
 }
 
 impl Default for Code {

crates/runner/src/runtime.rs

@@ -1,5 +1,6 @@
 use frame_support::runtime;
 
+use pallet_revive::AccountId32Mapper;
 use polkadot_sdk::*;
 use polkadot_sdk::{
     polkadot_sdk_frame::{log, runtime::prelude::*},
@@ -7,7 +8,7 @@ use polkadot_sdk::{
 };
 
 pub type Balance = u128;
-pub type AccountId = pallet_revive::DefaultAddressMapper;
+pub type AccountId = pallet_revive::AccountId32Mapper<Runtime>;
 pub type Block = frame_system::mocking::MockBlock<Runtime>;
 pub type Hash = <Runtime as frame_system::Config>::Hash;
 pub type EventRecord =
@@ -74,7 +75,7 @@ impl pallet_revive::Config for Runtime {
     type ChainExtension = ();
     type DepositPerByte = DepositPerByte;
     type DepositPerItem = DepositPerItem;
-    type AddressMapper = AccountId;
+    type AddressMapper = AccountId32Mapper<Self>;
     type RuntimeMemory = ConstU32<{ 512 * 1024 * 1024 }>;
     type PVFMemory = ConstU32<{ 1024 * 1024 * 1024 }>;
     type UnsafeUnstableInterface = UnstableInterface;

crates/runner/src/specs.rs

@@ -1,6 +1,5 @@
 use std::time::Instant;
 
-use pallet_revive::AddressMapper;
 use serde::{Deserialize, Serialize};
 
 use crate::*;

crates/runtime-api/src/polkavm_imports.c

@@ -78,7 +78,7 @@ POLKAVM_IMPORT(void, caller, uint32_t)
 
 POLKAVM_IMPORT(void, chain_id, uint32_t)
 
-POLKAVM_IMPORT(uint32_t, code_size, uint32_t)
+POLKAVM_IMPORT(uint32_t, code_size, uint32_t, uint32_t)
 
 POLKAVM_IMPORT(void, code_hash, uint32_t, uint32_t)
 
@@ -96,6 +96,8 @@ POLKAVM_IMPORT(uint32_t, instantiate, uint32_t)
 
 POLKAVM_IMPORT(void, now, uint32_t)
 
+POLKAVM_IMPORT(void, origin, uint32_t)
+
 POLKAVM_IMPORT(void, seal_return, uint32_t, uint32_t, uint32_t)
 
 POLKAVM_IMPORT(uint32_t, set_storage, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)

crates/runtime-api/src/polkavm_imports.rs

@@ -46,6 +46,8 @@ pub static INSTANTIATE: &str = "instantiate";
 
 pub static NOW: &str = "now";
 
+pub static ORIGIN: &str = "origin";
+
 pub static RETURN: &str = "seal_return";
 
 pub static SET_STORAGE: &str = "set_storage";
@@ -60,7 +62,7 @@ pub static VALUE_TRANSFERRED: &str = "value_transferred";
 
 /// All imported runtime API symbols.
 /// Useful for configuring common attributes and linkage.
-pub static IMPORTS: [&str; 24] = [
+pub static IMPORTS: [&str; 25] = [
     SBRK,
     MEMORY_SIZE,
     ADDRESS,
@@ -79,6 +81,7 @@ pub static IMPORTS: [&str; 24] = [
     INPUT,
     INSTANTIATE,
     NOW,
+    ORIGIN,
     RETURN,
     RETURNDATACOPY,
     RETURNDATASIZE,

crates/solidity/build.rs

@@ -0,0 +1,9 @@
+fn main() {
+    let git_rev = std::process::Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .map(|out| String::from_utf8(out.stdout).unwrap_or_default())
+        .unwrap_or("unknown".to_owned());
+
+    println!("cargo:rustc-env=GIT_COMMIT_HASH={}", git_rev.trim());
+}

crates/solidity/src/build/mod.rs

@@ -8,6 +8,7 @@ use std::path::Path;
 use crate::solc::combined_json::CombinedJson;
 use crate::solc::standard_json::output::Output as StandardJsonOutput;
 use crate::solc::version::Version as SolcVersion;
+use crate::ResolcVersion;
 
 use self::contract::Contract;
 
@@ -40,11 +41,7 @@ impl Build {
     }
 
     /// Writes all contracts assembly and bytecode to the combined JSON.
-    pub fn write_to_combined_json(
-        self,
-        combined_json: &mut CombinedJson,
-        resolc_version: &semver::Version,
-    ) -> anyhow::Result<()> {
+    pub fn write_to_combined_json(self, combined_json: &mut CombinedJson) -> anyhow::Result<()> {
         for (path, contract) in self.contracts.into_iter() {
             let combined_json_contract = combined_json
                 .contracts
@@ -61,7 +58,7 @@ impl Build {
             contract.write_to_combined_json(combined_json_contract)?;
         }
 
-        combined_json.zk_version = Some(resolc_version.to_string());
+        combined_json.revive_version = Some(ResolcVersion::default().long);
 
         Ok(())
     }
@@ -71,7 +68,6 @@ impl Build {
         mut self,
         standard_json: &mut StandardJsonOutput,
         solc_version: &SolcVersion,
-        resolc_version: &semver::Version,
     ) -> anyhow::Result<()> {
         let contracts = match standard_json.contracts.as_mut() {
             Some(contracts) => contracts,
@@ -90,7 +86,7 @@ impl Build {
 
         standard_json.version = Some(solc_version.default.to_string());
         standard_json.long_version = Some(solc_version.long.to_owned());
-        standard_json.zk_version = Some(resolc_version.to_string());
+        standard_json.revive_version = Some(ResolcVersion::default().long);
 
         Ok(())
     }

crates/solidity/src/lib.rs

@@ -7,6 +7,7 @@ pub(crate) mod missing_libraries;
 pub(crate) mod process;
 pub(crate) mod project;
 pub(crate) mod solc;
+pub(crate) mod version;
 pub(crate) mod warning;
 pub(crate) mod yul;
 
@@ -38,6 +39,7 @@ pub use self::solc::standard_json::output::contract::Contract as SolcStandardJso
 pub use self::solc::standard_json::output::Output as SolcStandardJsonOutput;
 pub use self::solc::version::Version as SolcVersion;
 pub use self::solc::Compiler as SolcCompiler;
+pub use self::version::Version as ResolcVersion;
 pub use self::warning::Warning;
 
 pub mod test_utils;
@@ -197,7 +199,6 @@ pub fn standard_json(
 ) -> anyhow::Result<()> {
     let solc_version = solc.version()?;
     let solc_pipeline = SolcPipeline::new(&solc_version, force_evmla);
-    let resolc_version = semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid");
 
     let solc_input = SolcStandardJsonInput::try_from_stdin(solc_pipeline)?;
     let source_code_files = solc_input
@@ -244,14 +245,10 @@ pub fn standard_json(
 
     if detect_missing_libraries {
         let missing_libraries = project.get_missing_libraries();
-        missing_libraries.write_to_standard_json(
-            &mut solc_output,
-            &solc_version,
-            &resolc_version,
-        )?;
+        missing_libraries.write_to_standard_json(&mut solc_output, &solc_version)?;
     } else {
         let build = project.compile(optimizer_settings, include_metadata_hash, debug_config)?;
-        build.write_to_standard_json(&mut solc_output, &solc_version, &resolc_version)?;
+        build.write_to_standard_json(&mut solc_output, &solc_version)?;
     }
     serde_json::to_writer(std::io::stdout(), &solc_output)?;
     std::process::exit(0);
@@ -278,8 +275,6 @@ pub fn combined_json(
     output_directory: Option<PathBuf>,
     overwrite: bool,
 ) -> anyhow::Result<()> {
-    let resolc_version = semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid");
-
     let build = standard_output(
         input_files,
         libraries,
@@ -298,7 +293,7 @@ pub fn combined_json(
     )?;
 
     let mut combined_json = solc.combined_json(input_files, format.as_str())?;
-    build.write_to_combined_json(&mut combined_json, &resolc_version)?;
+    build.write_to_combined_json(&mut combined_json)?;
 
     match output_directory {
         Some(output_directory) => {

crates/solidity/src/missing_libraries.rs

@@ -5,6 +5,7 @@ use std::collections::HashSet;
 
 use crate::solc::standard_json::output::Output as StandardJsonOutput;
 use crate::solc::version::Version as SolcVersion;
+use crate::ResolcVersion;
 
 /// The missing Solidity libraries.
 pub struct MissingLibraries {
@@ -23,7 +24,6 @@ impl MissingLibraries {
         mut self,
         standard_json: &mut StandardJsonOutput,
         solc_version: &SolcVersion,
-        resolc_version: &semver::Version,
     ) -> anyhow::Result<()> {
         let contracts = match standard_json.contracts.as_mut() {
             Some(contracts) => contracts,
@@ -43,7 +43,7 @@ impl MissingLibraries {
 
         standard_json.version = Some(solc_version.default.to_string());
         standard_json.long_version = Some(solc_version.long.to_owned());
-        standard_json.zk_version = Some(resolc_version.to_string());
+        standard_json.revive_version = Some(ResolcVersion::default().long);
 
         Ok(())
     }

crates/solidity/src/project/contract/metadata.rs

@@ -2,6 +2,8 @@
 
 use serde::Serialize;
 
+use crate::ResolcVersion;
+
 /// The Solidity contract metadata.
 /// Is used to append the metadata hash to the contract bytecode.
 #[derive(Debug, Serialize)]
@@ -9,11 +11,11 @@ pub struct Metadata {
     /// The `solc` metadata.
     pub solc_metadata: serde_json::Value,
     /// The `solc` version.
-    pub solc_version: semver::Version,
-    /// The zkVM `solc` edition.
-    pub solc_zkvm_edition: Option<semver::Version>,
+    pub solc_version: String,
+    /// The pallet revive edition.
+    pub revive_pallet_version: Option<semver::Version>,
     /// The PolkaVM compiler version.
-    pub zk_version: semver::Version,
+    pub revive_version: String,
     /// The PolkaVM compiler optimizer settings.
     pub optimizer_settings: revive_llvm_context::OptimizerSettings,
 }
@@ -22,16 +24,15 @@ impl Metadata {
     /// A shortcut constructor.
     pub fn new(
         solc_metadata: serde_json::Value,
-        solc_version: semver::Version,
-        solc_zkvm_edition: Option<semver::Version>,
-        zk_version: semver::Version,
+        solc_version: String,
+        revive_pallet_version: Option<semver::Version>,
         optimizer_settings: revive_llvm_context::OptimizerSettings,
     ) -> Self {
         Self {
             solc_metadata,
             solc_version,
-            solc_zkvm_edition,
-            zk_version,
+            revive_pallet_version,
+            revive_version: ResolcVersion::default().long,
             optimizer_settings,
         }
     }

crates/solidity/src/project/contract/mod.rs

@@ -89,9 +89,8 @@ impl Contract {
 
         let metadata = Metadata::new(
             self.metadata_json.take(),
-            version.default.clone(),
+            version.long.clone(),
             version.l2_revision.clone(),
-            semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid"),
             optimizer.settings().to_owned(),
         );
         let metadata_json = serde_json::to_value(&metadata).expect("Always valid");

crates/solidity/src/resolc/main.rs

@@ -31,10 +31,9 @@ fn main_inner() -> anyhow::Result<()> {
 
     if arguments.version {
         println!(
-            "{} v{} (LLVM build {:?})",
+            "{} version {}",
             env!("CARGO_PKG_DESCRIPTION"),
-            env!("CARGO_PKG_VERSION"),
-            inkwell::support::get_llvm_version()
+            revive_solidity::ResolcVersion::default().long
         );
         return Ok(());
     }

crates/solidity/src/solc/combined_json/mod.rs

@@ -28,7 +28,7 @@ pub struct CombinedJson {
     pub version: String,
     /// The `resolc` compiler version.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub zk_version: Option<String>,
+    pub revive_version: Option<String>,
 }
 
 impl CombinedJson {

crates/solidity/src/solc/standard_json/output/mod.rs

@@ -45,7 +45,7 @@ pub struct Output {
     pub long_version: Option<String>,
     /// The `resolc` compiler version.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub zk_version: Option<String>,
+    pub revive_version: Option<String>,
 }
 
 impl Output {

crates/solidity/src/test_utils.rs

@@ -3,7 +3,6 @@ use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::HashMap;
 use std::path::PathBuf;
-use std::str::FromStr;
 use std::sync::Mutex;
 
 use once_cell::sync::Lazy;
@@ -106,11 +105,7 @@ pub fn build_solidity_with_options(
     let project = output.try_to_project(sources, libraries, pipeline, &solc_version, None)?;
 
     let build: crate::Build = project.compile(optimizer_settings, false, None)?;
-    build.write_to_standard_json(
-        &mut output,
-        &solc_version,
-        &semver::Version::from_str(env!("CARGO_PKG_VERSION"))?,
-    )?;
+    build.write_to_standard_json(&mut output, &solc_version)?;
 
     Ok(output)
 }
@@ -202,11 +197,7 @@ pub fn build_solidity_and_detect_missing_libraries(
     let project = output.try_to_project(sources, libraries, pipeline, &solc_version, None)?;
 
     let missing_libraries = project.get_missing_libraries();
-    missing_libraries.write_to_standard_json(
-        &mut output,
-        &solc.version()?,
-        &semver::Version::from_str(env!("CARGO_PKG_VERSION"))?,
-    )?;
+    missing_libraries.write_to_standard_json(&mut output, &solc.version()?)?;
 
     Ok(output)
 }
@@ -232,14 +223,14 @@ pub fn check_solidity_warning(
     warning_substring: &str,
     libraries: BTreeMap<String, BTreeMap<String, String>>,
     pipeline: SolcPipeline,
-    skip_for_zkvm_edition: bool,
+    skip_for_revive_edition: bool,
     suppressed_warnings: Option<Vec<Warning>>,
 ) -> anyhow::Result<bool> {
     check_dependencies();
 
     let mut solc = SolcCompiler::new(SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned())?;
     let solc_version = solc.version()?;
-    if skip_for_zkvm_edition && solc_version.l2_revision.is_some() {
+    if skip_for_revive_edition && solc_version.l2_revision.is_some() {
         return Ok(true);
     }
 

crates/solidity/src/version.rs

@@ -0,0 +1,30 @@
+//! The resolc compiler version.
+
+use serde::Deserialize;
+use serde::Serialize;
+
+/// The resolc compiler version.
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct Version {
+    /// The long version string.
+    pub long: String,
+    /// The short `semver`.
+    pub default: semver::Version,
+    /// The LLVM version string.
+    pub llvm: semver::Version,
+}
+
+impl Default for Version {
+    fn default() -> Self {
+        let default = semver::Version::parse(env!("CARGO_PKG_VERSION")).expect("Always valid");
+        let commit = env!("GIT_COMMIT_HASH");
+        let (llvm_major, llvm_minor, llvm_patch) = inkwell::support::get_llvm_version();
+        let llvm = semver::Version::new(llvm_major as u64, llvm_minor as u64, llvm_patch as u64);
+
+        Self {
+            long: format!("{default}+commit.{commit}.llvm-{llvm}"),
+            default,
+            llvm,
+        }
+    }
+}