This release contains the changes from polkadot-stable2509 to polkadot-stable2512-rc1.

⚠️ Warning: Pre-release Version

The currently published version is a pre-release and is not yet a final stable version. This release is provided for testing purposes only, and there is no guarantee that everything will work as expected. Errors and unusual behaviours of some features are to be expected.

Please use this version at your own risk and report any issues you encounter. We recommend waiting for the official release if you need a stable version.

Changelog

Changelog for Node Dev

ℹ️ These changes are relevant to: Those who build around the client side code. Alternative client builders, SMOLDOT, those who consume RPCs. These are people who are oblivious to the runtime changes. They only care about the meta-protocol, not the protocol itself.

[#9418]: frame/revive: ETH block storage

This PR constructs the Ethereum block in the following way:

• events (logs) are captured via an environmental! variable to reduce reliance on pallet storage
  • A maximum of 512 events is allowed per transaction, with the size of an event capped to self.ext.max_value_size()
• A memory-efficient intermediate block builder is deserialized and serialized back to the pallet storage
  • The intermediate block builder builds the transaction and event root hashes using low level RLP encoding primitives to achieve around 90% pallet storage optimization
  • For more details, see #9764
• A fixup is included for 7702 transaction rlp serialization/deserialization is added to ensure we can build the Ethereum block hash from live Ethereum blocks.
• The maximum CALL_PARAMS_MAX_SIZE is increased to 512 to 244 to accommodate the transaction added to the Eth call

This PR also includes benchmarking:

• #9496

Testing Done

• pallet storage testing and capturing of events / transactions are added at tests/block_hash.rs
• incremental block storage is tested in evm/block_hash.rs, which ensures RLP encoding / hash builder and identical hashes from live ethereum blocks
• tested via RPC work

Next Steps

• #9512
• #9616
• #9452

Builds upon #9413

Part of: paritytech/contract-issues#139

[#10056]: Upgrade litep2p 0.10.0 -> 0.11.0

This upgrade fixes the initialization of mDNS in the environment with no multicast addresses available and compatibility with kubo IPFS >= 0.37 when run with --ipfs-server. It also enables communication with remote peers having RSA network identity keys.

[#9990]: cumulus: Skip building on blocks on relay parents in old session

Collators building on older relay parents must skip building blocks when the chosen RP session is different than best block session.

The relay chain will not accept such candidate. We can see this happening on the Kusama Canary parachain at each session boundary.

Slot-based Aura has been modified in Cumulus to skip building blocks on relay parents in old session.

[#10048]: cumulus-bootnodes: Do not require a specific hash

On the wire the hash is represented as Vec<u8> any way. So, there is no need to take this as an extra type.

[#9443]: move released primitives and APIs out of staging

Solves #9400

No logic change, only moves types from polkadot/primitives/src/vstaging into polkadot/primitives/src/v9 (renamed from v8 to v9).

[#10145]: Send PeerId via UMP

Resolves #7749

This PR propagates the network PeerId of the collator to the parachain inherent.
Then the parachain runtime emits a UMP signal containing the collator PeerId.

[#9884]: Add criterion benches for statement-store

Description

Adds micro benches simulating concurrent work with the statement-store.

Integration

This PR does not not affect downstream projects.

[#10129]: Add upload evm code function

EVM Runtime Code Upload for Foundry Integration
This feature enables direct upload of EVM runtime bytecode (deployed contract code without constructor) to the pallet-revive, supporting Foundry's code migration functionality between REVM and pallet-revive execution environments.

[#9909]: pallet-revive: add interface to implement mocks and pranks

Needed for: paritytech/foundry-polkadot#334.

In foundry-polkadot we need the ability to be able to manipulate the msg.sender and the tx.origin that a solidity contract sees cheatcode documentation, plus the ability to mock calls and functions.

Currently all create/call methods use the bare_instantiate/bare_call to run things in pallet-revive, the caller then normally gets set automatically, based on what is the call stack, but for forge test we need to be able to manipulate, so that we can set it to custom values.

Additionally, for delegate_call, bare_call is used, so there is no way to specify we are dealing with a delegate call, so the call is not working correcly.

For both this paths, we need a way to inject this information into the execution environment, hence I added an optional hooks interface that we implement from foundry cheatcodes for prank and mock functionality.

[#10147]: Upgrade arkworks 0.4.1 -> 0.5.0

Arkworks minor upgrade and some refactory.

[#10155]: RawIter: stop iterating on incomplete DB only with stop_on_incomplete_database

On RawIter there is an argument stop_on_incomplete_database. In contrast to what it is saying, the Iterator was always stopping on incomplete DB.

[#9921]: Log consistency: use para_id= like everywhere else, instead of para=

We incoherently sometimes use "para=" and sometimes "para_id=", this PR fixes that. This
makes it easier to follow the path of a parablock in logs, e.g. Loki (Grafana).

[#9869]: Removes legacy consensus code that was no longer used.

Removes the ParachainConsensus trait and legacy consensus code that was no longer used.

[#9920]: [debug]: change impl of Debug of (para)Id to be just "".

The std::fmt::Debug impl (derived) of Id results in "Id(42)" instead of "42", this causes discrepancies in logs.
Sometimes we log "para_id=Id(3392)" but sometimes we log "para_id=3392" (without the "Id()").

This makes e.g. Grafana PromQL queries harder to do, and logs harder to search in general.

This PR changes the impl of Debug to be just "".

[#9929]: Pre-connect to backers before own slot

Implements a mechanism to pre-connect to backers, see #9767 (comment).
Improve backing group connectivity.

[#9664]: basic-authorship: Improve inherent logging

This PR aims to improve the inherent logging situation a bit. After the recent incident it was unnecessary painful to figure out what exactly happened. The logs should now be a bit more clear.

• We get how many inherents where provided by the runtime
• We get the names of the data items

[#9691]: DB: Ensure that when we revert blocks, we actually delete all their data

Delete block data on revert and ensure the cache is also cleared.

[#10286]: Fix some 'unnecessary parentheses around type' warnings

Removes some unnecessary parentheses around types to fix compilation warnings.

[#10242]: Upgrade kvdb-rocksdb

This includes a fix for when we are writing a lot of state, e.g. after a warp sync. In this case the rocksdb will compact its own db to improve read speed.

[#9878]: pallet-revive: add custom addr recovery logic in ReceiptExtractor

Add ability to customize pallet-revive-eth-rpc's ReceiptExtractor ethereum address recovery logic, used when parsing through blocks' transactions.

[#10162]: Make tasks local only.

In frame-system: tasks are now only valid from local source, external source is invalid.

The reason is that transaction are identified by their provided tag in the transaction pool, tasks provided tag is simply the hash of the tasks. Therefore, depending on how tasks are written, it may be possible to have a very large number of tasks that actually do the same operation but where the hash is different, thus it can be used to spam the transaction pool. A simple solution against this is to accept tasks only from local source.

Fix: #9693

[#9904]: FinalityNotification: Directly include stale blocks

The finality notification was already carrying the information about the stale heads. However, most users of the stale heads were expanding these stale heads to all the stale blocks. So, we were iterating the same forks multiple times in the node for each finality notification. Also in a possible future where we start actually pruning headers as well, expanding these forks would fail.

So, this pull request is changing the finality notification to directly carry the stale blocks (which were calculated any way already).

[#9811]: Elastic scaling runtime upgrade tests

Add runtime upgrade tests for sync and async backing chains

[#9774]: Fix executor param fetching session index

Fix executor environment parameters fetching inconsistency

[#9662]: Removes deprecated collator-related code in cumulus

Removes deprecated collator-related code in cumulus.

[#10103]: rpc-v2/archive: Remove unused structs and align with 1.90 rust

This PR removes unused structures from the RPC V2 archive.

While at it, remove unnecessary parentheses to make clippy happy.

cc @paritytech/subxt-team

[#10304]: Reenable interest-cache for tracing-log

Reenable interest-cache for tracing-log crate.

See #8760 (comment)

[#9701]: revive-rpc: use generic RpcClient

Support for a generic RPC client in the revive eth rpc proxy, instead of the previously hardcoded
ReconnectingRpcClient. This enables more flexible usage of the revive rpc as a library.

[#9927]: Log: log candidate_hash nor the pov_hash when collations expire

When collations expire we do not log the candidate_hash nor the pov_hash, making it hard to map the
logged entries about Candidate generated and Candidate expired together.

This PR adds pov_hash and candidate_hash to the CollationStats struct and use these fields when we
log "Collation expired".

[#9844]: prospective-parachains: add more logs

Log all candidate processing errors (especially FragmentValidityError) to observe how many
are dropped and why.

[#9417]: Measure backed in block count vs backable

Added a mechanism to measure the difference between the number of candidates
backed on chain versus offchain from the perspective of the node.

[#9976]: Log: fix bug where incorrect relay_parent was used for expired collations.

Fixes a bug in logging of expried collations, the wrong relay_parent hash
was used.

Now we properly log the correct relay_parent in the "Collation expired"
message.

[#10329]: fix: support paginationStartKey parameter for archive_v1_storage

Fixes #10185

This PR is to add support for paginationStartKey parameter in archive_v1_storage JSON RPC API for query type: descendantsValues and descendantsHashes per the latest specs.

[#9550]: basic-authorship: end_reason improved

The end_reason reported in block authoring can be misleading when resource limits are hit. The basic authorship module tries additional transactions after hitting limits, and if it runs out of transactions or time during this extended trial phase, it reports the inaccurate reason.
This PR proposes to change the actual end_reason to be more accurate.

[#10175]: revive-eth-rpc: fix blocks pruning

Fixes the blocks pruning for the revive eth rpc in case of forks or chain reversions.

[#9821]: wasmtime: support for perfmap added

This PR add support for perfmap in wasmtime executor.

For more technical details refer to this doc.

Instruction on how to configure profiling on substrate nodes (tested with cumulus benchmarks) is here.

The following environment variable needs to be set when executing the node binary:

export WASMTIME_PROFILING_STRATEGY=perfmap

[#9178]: collator-protocol: cleanup connecting to backing group

Have collators always connect to the backing group they got assigned to and keep the connection open
until backing group changes. Also, try to connect when have something to advertise or on timeout to
have more chances of being correctly connected.

[#9930]: Introduce ReplayProofSizeProvider, RecordingProofProvider & transactional extensions

The ProofSizeExt extension is used to serve the proof size to the runtime. It uses the proof recorder to request the current proof size. The RecordingProofProvider extension can record the calls to the proof size function. Later the ReplayProofSizeProvider can be used to replay these recorded proof sizes. So, the proof recorder is not required anymore.

Extensions are now also hooked into the transactional system. This means they are called when a new transaction is created and informed when a transaction is committed or reverted.

[#10194]: Fix executor parameters classification

Executor parameters may be hashed in two ways: a full hash that changes if any parameter changes, and a prep_hash, which changes only if the parameter change will affect the prepared artifact (thus requiring artifact recompilation).
This PR aims to fix a bug in the initial classification and to add a test that should prevent those bugs from happening in the future.

[#9295]: MMR: add ancestry proof generation runtime method and RPC call

This PR adds the mmr_generateAncestryProof call to the RPC.

[#10305]: Cumulus: fix pre-connect to backers for single collator parachains

When running a single collator (most commonly on testnets), the block builder task is always
able to claim a slot, so we're never triggering the pre-connect mechanism which happens for
slots owned by other authors.

Changelog for Runtime Dev

ℹ️ These changes are relevant to: All of those who rely on the runtime. A parachain team that is using a pallet. A DApp that is using a pallet. These are people who care about the protocol (WASM, not the meta-protocol (client).)

[#9679]: [pallet-revive] fix GAS_PRICE

Currently submitting a transaction to the dev-node or kitchensink will trigger an error when you try to submit a transaction trough cast (or anything using alloy) as the block gas limit on these runtime is greater than u64::max.

This bumps the GAS_PRICE to fix this issue, this will eventually be superseeded by the new gas model

[#10169]: pallet-revive-eth-rpc: derive Encode/Decode for subxt-generated types

Derive scale encode/decode for subxt-generated types in pallet-revive-eth-rpc

[#9801]: [pallet-revive] allow changing immutables

Adds pallet revive methods for reading and setting immutables data of a contract.

Fixes: paritytech/foundry-polkadot#277

[#8053]: Add OnNewCommitment hook to outbound-queue pallet

Add a simple hook to outbound-queue-v2 pallet which allows to perform actions whenever there is a new commitment.

[#10284]: add fresh weights for westend asset hub

• deprecate FastUnstake as it is unsafe
• And use the faster solver for benchmarks to speed things up
• Remove hardcoded weights of westend.

A step to reduce the diff size in #9925

[#9853]: [pallet-revive] update rpc md

Update eth-rpc metadata files

[#9731]: simulate rank_to_votes conversion in vote benchmark

Fixes benchmarking failures for the vote extrinsic in pallet-ranked-collective by properly
simulating the rank_to_votes conversion process. Previously used hardcoded vote values
which caused assertion failures when using custom VoteWeight converters (e.g., in
Ambassador Collective configuration). The fix calculates vote weight based on member's
actual rank and minimum required rank for the class.

[#9768]: pallet revive evm backend add tests for cross vm contract calls

fixes #9576

[#10272]: pallet-revive: add hook for mocking origin

While runing some balancer v3 tests paritytech/foundry-polkadot#287 (comment), discovered we need a way to mock up the origin as well, so add hook.

[#10146]: eth-rpc - fix subscription race

fix #10139 (comment)

[#10239]: [pallet-revive] fix prestate tracer current address

Fix prestate tracer not reporting the contract addresses properly.

[#10148]: revive fix reported gas used

Fix gas_used calculation introduced in #9418 to use the actual gas instead of just ref_time.

With these changes we now guarantee that tx_cost = effective_gas_price * gas.
Note that since we compute gas as fee / gas_price, this can lead to rounding errors when the chain uses SlowAdjustingFeeUpdate (i.e. the fee is not a multiple of the gas price).
The changes in this PR ensure the fee still matches by burning the rounding remainder.

This PR also fixes how the actual fee is computed and introduces a new compute_actual_fee in Config::FeeInfo.
The previous fee calculation was skipping the extension_weight in the fee calculation.

The updated tests ensure that the tx cost reported in the receipt matches the fees deducted from the user account:

https://github.com/paritytech/evm-test-suite/blob/460b2c9aa3a3019d3508bb5a34a2498ea86035ff/src/gas.test.ts?plain=1#L31-L61

[#9443]: move released primitives and APIs out of staging

Solves #9400

No logic change, only moves types from polkadot/primitives/src/vstaging into polkadot/primitives/src/v9 (renamed from v8 to v9).

[#10297]: pallet_revive: use real storage for block number when building the eth genesis block

When building the eth genesis block, query the real storage item that stores the block number instead of using zero.
If the chainspec does not customise it, it will remain zeroed. Was previously fixed in #10225
and regression introduced in #10271. Adds a unit test and comment to prevent further regressions.

[#9952]: Snowbridge: Fix log equal check

This fix addresses an issue introduced in PR#9204, where individual event log topics were not fully verified.

[#10127]: Deny parameters for pallet macros that do not support parameters

E.g. pallet::constant.

[#10159]: Add eth_substrate_call extrinsic.

Fixes paritytech/contract-issues#180
This PR introduces eth_substrate_call, a new extrinsic in pallet-revive that enables Substrate runtime calls from Ethereum transactions. This allows tools like Hardhat to invoke Substrate extrinsics (e.g., upload_code) via the Ethereum RPC.

This implements a new approach for dispatching Substrate extrinsics through the magic RUNTIME_PALLETS_ADDR address, which fixes two shortcomings of the previous implementation:

1. Incorrect origin verification - The origin is now correctly verified as EthTransaction.
2. Missing Ethereum transaction receipts - Receipts are now properly generated for all Ethereum transactions.

Includes:

• New eth-rpc integration test validating end-to-end functionality
• Benchmark measuring the extrinsic overhead
• Unit tests

[#9771]: [pallet-revive] fix salt endianness

fix #9769

[#9670]: Move revive fixtures into release directory

#8980 did fix the fellowship CI but it triggers a rebuild of the fixtures every single time you run tests. Annoying during development.

Instead of rebuilding, we just move the fixtures into the target/release directory where it should be cached by the fellowship CI.

Verifying that it works here: polkadot-fellows/runtimes#891

Why: Re-running when the output dir changes will make it re-run every time. Since every run changes the output dir.

[#9914]: Wait for transaction receipt if instant seal is enabled

Fixes paritytech/contract-issues#165

The main changes in this PR are:

1. Add a new API to revive-dev-node to check whether the node has instant seal enabled.
2. Add a new debug API to eth-rpc to check whether the node has instant seal enabled. (optional)
3. Query and cache the node’s instant seal status during eth-rpc initialization.
4. If instant seal is enabled, wait for the transaction receipt to be available

[#9561]: added trace logging in EVM interpreter loop

Added trace logging for each instruction to evm::run function.
solves #9575

[#9293]: Enable async-backing on Penpal

To enable async-backing on Penpal.

[#9997]: [pallet-revive] Implement the consume_all_gas syscall

This PR implements a new API consume_all_gas which is required for 100% EVM INVALID opcode compatibility.

Since ceding of all remaining gas is handled in the EVM interpreter, I decided to not add a return flag but make this a dedicated syscall for consistency instead.

Didn't implement a benchmark since the first (and only) thing this does is consuming all remaining gas anyways.

[#10083]: bump jsonrpsee to 0.24.10

Bump jsonrpsee to 0.24.10 so that we can use the request logger with proper trace scopping (see paritytech/jsonrpsee#1609) for more details

this will let us run the eth-rpc with jsonrpsee-server=trace to capture request and responses from the request logger middleware

[#10220]: Notify when there is a new best block

Description

Modify the tx_notifier to send the block hash to the subscribers instead of all transactions hashes.
Modify the send_raw_transaction to look for the transaction hash in the transactions field of the evm block.

[#10298]: Fix the CodeNotFound issue in PolkaVM tests

Description

This PR bumps the commit hash of the revive-differential-tests framework to a version that contains a fix for the CodeNotFound issue we've been seeing with PolkaVM. The framework now uploads the code of all the contracts prior to running the tests.

When CI runs for this PR we should observe that there's either no more CodeNotFound errors in PolkaVM tests or that it's greatly reduced.

[#9736]: [pallet-revive] fix tracing collect

Fix tracing collection

collect_trace should take self instead of &mut self, to avoid reusing the tracer state when tracing multiple transactions in a block.

Fix paritytech/contract-issues#156

[#10020]: pallet-revive: Add ExportChainSpec command to revive-dev-node

Add the export-chain-spec command to the revive-dev-node.

[#10145]: Send PeerId via UMP

Resolves #7749

This PR propagates the network PeerId of the collator to the parachain inherent.
Then the parachain runtime emits a UMP signal containing the collator PeerId.

[#10193]: [v2] pallet-revive: support uploading EVM bytecode via upload_code

Fixes paritytech/contract-issues#182

Add support for EVM bytecode to the upload_code extrinsic.
Tests in issue paritytech/contract-issues#182 send hardhat_setCode, which uses revive's upload_code API; this change makes that flow accept and store the EVM bytecode using upload_code extrinsic.

[#10336]: fix P256Verify precompile address

fix paritytech/contract-issues#220

[#8757]: Allow sending transactions from an Ethereum address derived account id

We always allowed signing transactions using an Bitcoin/Eth style SECP256k1 key. The account in this case is simply the blake2 hash of the public key.

This address derivation is problematic: It requires the public key in order to derive the account id. On Ethereum you simply can't know the public key of an address. This is why the mapping in pallet_revive is defined as address <-> account_id.

This PR adds a new signature variant that allows signing a transaction with an account id as origin that matches this mapping.

Why is this important?

Example1

A wallet contains an SECP256k1 key and wants to interact with native Polkadot APIs. It can sign the transaction using this key. However, without this change the origin of that transaction will be different than the one it would appear under if it had signed an Ethereum transaction.

Example2

A chain using an Ethereum style address (like Mythical) wants to send some tokens to one of their users account on AssetHub. How would they know what is the address of that user on AssetHub? With this change they can just pad the address with 0xEE and rely on the fact that the user can interact with AssetHub using their existing key.

Why a new variant?

We can't modify the existing variant. Otherwise the same signature would suddenly map to a different account making people lose access to their funds. Instead, we add a new variant that adds control over an additional account for the same signature.

A new KeccakSigner and KeccakSignature

After considering feedback by @moliholy I am convinced that we should use keccak instead of blake2b for this new MultiSignature variant. Reasoning is that this will make it much simpler for Ethereum tooling to generate such signatures. Since this signature is specifically created for Ethereum interop it just makes sense to also use keccak here.
To that end I made the ecdsa::{KeccakSigner, KeccakSignature} generic over their hash algorithm. Please note that I am using tags here and not the Hasher trait directly. This makes things more complicated but it was necessary: All Hasher implementations are in higher level crates and can't be directly referenced here. But I would have to reference it in order to make this a non breaking change. The Signer and Signature types behave exactly the same way as before.

[#9857]: add RewardsPool trait

Add trait RewardsPool to frame-support and updated pallet-asset-rewards to implement it.
This allows other pallets to be able to use the RewardsPool trait to manage reward pools programmatically.

[#9480]: Lazy decode block extrinsics

Related to #4255

Addresses #7902 (review)

This PR enables us to lazily decode the block extrinsics when needed.

The PR changes the signature of the execute_block and check_inherents runtime APIs in order to receive
a LazyBlock instead of a Block. However LazyBlock and Block encode to the same byte sequence.
If some tools are using metadata, the type may appear as LazyBlock instead of Block.
But the underlying type is the same.

[#10117]: Configure cross-chain delivery fees for parachain template

Adds proper cross-chain delivery fees to the parachain template
for both UMP and HRMP.

[#10233]: not charging ED in ctor if account already has enough balance

fixes paritytech/contract-issues#179

[#9875]: Stronger WASM compression

Use strongest compression 22 instead of just 3. See docs.
Reduces our KAH compressed size by 25%.

[#10071]: Adding Retester to CI

Description

This PR adds differential tests as part of the CI of the polkadot SDK. Currently, a job will be started when pushing to master or when a PR is opened that runs the differential testing framework with the revive-dev-node-revm-resolc target.

[#9907]: CheckWeight: Take transaction length into account during validation

The CheckWeight extension now takes the length into account when checking whether a transaction fits into a block at validation time.

[#9815]: Introduce pallet-oracle

This PR is part of #9765 - Polkadot Stablecoin on AssetHub. It introduces pallet-oracle, a new FRAME pallet that provides a decentralized and trustworthy way to bring external, off-chain data onto the blockchain. The pallet allows a configurable set of oracle operators to feed data, such as prices, into the system, which can then be consumed by other pallets.

[#9414]: [pallet-revive] EVM backend: Implement tx, block system and call stack instructions

This PR is part of the road to EVM.

• Implement call and create frames, allowing to call and instantiate other contracts.
• Implement support for tx info, block info, system and contract opcodes.
• The InstructionResult <-> ExecError conversion functions.

[#10262]: Fix the issue with the blockhash tests

Description

This PR fixes an issue that we've been seeing with the blockhash tests in the MatterLabs test suite. It merges the fix from the differential tests repo that was made in PR #210. More information on the fix can be found in the PR's description, but I will also paste it here to make it easier:

This PR fixes an issue that was causing the blockhash.sol tests to fail when ran through retester which is described in #210. It was determined that the root cause of this failure was not an issue in revive but rather due to the eth-rpc pruning the blocks as the framework was running. This meant that by the time we attempted to retrieve the block hash from the eth-rpc it would've already been pruned since other blocks were mined and these blocks were pruned.

This explains the indeterminism that we saw with these tests with them sometimes succeeding and sometimes failing. This can be explained away by the async task sometimes being scheduled to run right after the transaction was submitted and before other blocks were mined and therefore we succeed in getting the block hash and sometimes it takes a while to run and by the time it runs the block has already been pruned from the eth-rpc.

We've increases the cache size and the number of indexed blocks to 1,000 which should hopefully give us enough room for async task scheduling to run and still be able to get the block hash.

We've bumped the commit hash of the revive-differential-tests framework to the commit hash that includes this fix.

In this PR we should observe that the blockhash.sol tests no longer fail. If they fail, then it means that this was an incorrect fix to the issue.

[#9712]: Cumulus aura-ext: Harden slot check between relay-parent and parachain

Before this PR, we were preventing parachains from authoring blocks that have a slot from the future. However, we permitted parachains to author on past slots, which is unnecessary relaxed. This PR enforces that only the author that owns the slot corresponding to the slot of the relay parent can author.
This should no impact on normal Parachain operation. Blocks are already produced on the correct slots, this increased strictness improves some edge-cases however.
Even before, the Parachains slot needed to strictly advance, so production on "older" slots was only possible if previous authors skipped production opportunities.

Breaking Changes

Test breakage is expected. Users of polkadot-sdk who have integration tests or dev-nodes which rely on block production need to supply correct AURA digests. The simplest way to make block production work in test scenarios is to always supply a digest which contains the same slot as the relay parent.
In addition, the timestamp inherent passed to the blocks needs to match that slot in the digest.

• Users of xcm-emulator: Use a DigestProvider similar to emulated_integration_tests_common::AuraDigestProvider.
• Users of MockValidationDataInherentDataProvider: Use sc-consensus-manual-seal::AuraConsensusDataProvider.

[#9985]: pallet-xcm: extract precompiles to a separate crate

This PR extracts the XCM precompile from pallet-xcm into a new standalone crate pallet-xcm-precompiles to resolve an unwanted dependency issue. Previously, the XCM precompile was implemented directly in pallet-xcm/src/precompiles.rs, which required pallet-xcm to depend on pallet-revive, introducing it as a transitive dependency for all parachains using pallet-xcm.

Closes #9955

[#10109]: revive-dev-node enforce --dev

enforce --dev and default --log in revive-dev-node

[#9471]: Support for generating proof of possession alongside signing on the owner's Id

When signing on a new session key, the signer must also use the session key to sign on the authority’s signer key in order to prove that it is not faking the ownership of someone else’s key. This, in part, prevents mounting a front-runner attack.

On the other hand, for aggregatable crypto schemes, such as BLS, to be secure, the authority submitting a new session key should prove it is in possession of the private key. To prevent these proofs from abuse, a specific statement in a separate domain must be used in signing, one that is never used in the usual signing process. This is to prevent the rogue key attack described in [1].

This means that those schemes need to submit two signatures to prove the legitimacy of the submitted session key, in contrast to non-aggregatable schemes, which need one.

Additionally, it is foreseeable that in the future, some crypto schemes might require the key submitter to prove other facts before accepting their submission.

To accommodate such flexibility, this PR introduces a new customized type ProofOfPossession for Pairs (in addition to Public and Signature) to represent these proofs.

Currently ProofOfPossession = Signature for ecdsa, ed25519 and sr25519 while ProofOfPossession = Signature | Signature for bls381 and ProofOfPossession = ecdsa:Signature | bls381:Signature | bls381:Signatureforecdsa_bls381` paired_key scheme.

• [1] Ristenpart, T., & Yilek, S. (2007). The power of proofs-of-possession: Securing multiparty signatures against rogue-key attacks. In , Annual International Conference on the Theory and Applications of Cryptographic Techniques (pp. 228–245).: {Springer}.

[#9988]: [pallet-revive] improve revive genesis config

GenesisConfig: make sure that contracts are brought to existence by minting e.d first

[#9945]: pallet-revive update basefee instruction

The base fee instruction now returns the proper base price instead of a hard coded value.

[#9948]: pallet-assets: add reserves info to support non-teleportable Foreign Assets on Asset Hub

This PR adds a new storage item and new call to pallet-assets that can be used to configure
the trusted reserves (as seen by the local chain) on a per-asset basis. This is a generic
type that is flexible at the runtime level. It can be an XCM Location or any other type of
location information, or it can be set to () if the assets managed by the pallet instance
do not require any remote reserves information.

The PR also adds helper machinery for runtimes to use the assets reserves information when
reasoning about XCM teleports and XCM reserve-based transfers.

For example, in Westend Asset Hub's case, for each asset, only explicitly configured
assets' reserve locations will be trusted. Besides the actual reserve location(s), a
teleportable: bool flag is also set for each reserve, specifying whether the asset is
teleportable or not between the local chain and said reserve location.
Any other chain that should be assumed as a trusted reserve needs to be marked as such
in pallet-assets by the asset's Owner.

By default, on asset creation, no explicit reserve information is configured. This
results in foreign assets not being transferable cross-chain by default. To enable
cross-chain transfers, one of the following configurations is required on the Asset to
be done by its Owner:

• For AH to accept incoming reserve transfer of asset "A" from remote chain "X", that
  chain needs to be added as a trusted reserve for asset "A", and teleportable flag set
  to false:

  let asset_id = "A";
  let origin = Signed(OwnerOfA);
  let reserves = vec![
    ForeignAssetReserveData { reserve: "Remote Chain X location", teleport: false }
  ];
  pallet_assets::set_reserves(origin, asset_id, reserves);

• For AH to accept teleports of asset "A" from remote chain "X", that chain needs to be
  added as trusted reserves for asset "A", and teleportable flag set to true:

  let asset_id = "A";
  let origin = Signed(OwnerOfA);
  let reserves = vec![
    ForeignAssetReserveData { reserve: "Remote Chain X location", teleport: true }
  ];
  pallet_assets::set_reserves(origin, asset_id, reserves);

[#9512]: frame/revive: ETH block storage

This PR adjusts the RPC layer of pallet-revive to use Ethereum blocks from storage via runtime APIs and establishes proper Ethereum ↔ Substrate block hash mappings.

Key Changes

Block Hash Mapping Infrastructure

• New database table: eth_to_substrate_blocks maps Ethereum block hashes to Substrate block hashes and block numbers
• Bidirectional lookups: Support for both ETH→Substrate and Substrate→ETH hash resolution with backward compatibility fallbacks
• Block pruning: Updated to remove stale mappings alongside transaction and log data

Pallet Changes

• Genesis block initialization: Added block_storage::on_finalize_build_eth_block() call in BuildGenesisConfig to properly build and store block 0

Testing

• Added comprehensive tests for block hash mapping operations
• Ethereum vs Substrate hash resolution tests
• Fork handling in block pruning tests
• Log filtering with Ethereum block hash tests
• TransactionInfo deserialization from JSON Value tests

Implementation Details

The implementation uses a runtime API approach where the RPC layer queries the runtime for Ethereum blocks and hashes, which are then mapped to Substrate block hashes in the local SQLite database. This provides:

1. Backward compatibility: Falls back to treating hashes as Substrate hashes when no mapping exists
2. Efficient lookups: Database indices on both Ethereum and Substrate block hashes
3. Automatic cleanup: Block mappings are pruned alongside transaction and log data
4. Genesis block handling: Block 0 is built during genesis using the block storage infrastructure

Builds upon: #9418
Part of: paritytech/contract-issues#139

[#10347]: Don't require PR for uploading comment for DT CI

Description

Small PR that changes the DT CI to not require a PR for uploading the report to the CI job.

[#10186]: Return the correct block difficulty from the eth-rpc

Description

This PR fixes an issue in the eth-rpc/pallet-revive that was causing it to return an incorrect value for the block's difficulty or prevrandao.

In the VM/interpreter implementation we use a constant for the block difficulty. However, the eth block construction side was unaware of this constant being used and therefore the RPC was always returning a block difficulty of zero.

[#9963]: Query delivery fees v2

BREAKING CHANGE

Adds a new parameter to XcmPaymentApi.query_delivery_fees to specify the asset id in which you'd like to get the delivery fees. This makes it possible to estimate how much to pay for fees for assets other than the native asset.

Fixes #7061

Continuation of #8297

[#9831]: Allow unlimited contract size in debug mode.

Fixes paritytech/contract-issues#167

The main changes in this PR are:

1. Added an associated type DebugEnabled
2. Introduced a DebugSettings struct with a single boolean field
3. Added a StorageValue: pub(crate) type DebugSettingsOf<T: Config> = StorageValue<_, DebugSettings, ValueQuery>;
4. Included debug_settings in the GenesisConfig
5. Added a unit test to verify that large EVM contracts can be instantiated.

[#10303]: pallet-revive fix prestate diff tracing

Fix prestate diff-tracing, add missing storage diff for created contracts

[#10290]: pallet-revive: fix eth tx decoding

Fix Ethereum transaction decoding

[#10090]: revive: fix alloy-consensus dependency

Bump the alloy-consensus version and include the serde feature in std

[#10225]: pallet_revive: use real storage when building the eth genesis block

When building the eth genesis block, query the real storage items that store the timestamp and block number instead of using the zeroed items.
If the chainspec does not customise these, they will remain zeroed.

[#9279]: Replace log with tracing on Snowbridge-related modules

This PR replaces log with tracing instrumentation on Snowbridge-related modules by providing structured logging.

[#10162]: Make tasks local only.

In frame-system: tasks are now only valid from local source, external source is invalid.

The reason is that transaction are identified by their provided tag in the transaction pool, tasks provided tag is simply the hash of the tasks. Therefore, depending on how tasks are written, it may be possible to have a very large number of tasks that actually do the same operation but where the hash is different, thus it can be used to spam the transaction pool. A simple solution against this is to accept tasks only from local source.

Fix: #9693

[#10158]: allow more generic origins in xcm-emulator message processor

Right now the default message processor is somewhat tied to specific AggregateMessageOrigin from polkadot_runtime_parachains::inclusion. this pr changes it so that we require a conversion from that AggregateMessageOrigin, but nothing else, the rest stays generic.

In the longer run we can allow customizing the processor to some other thing, but this was a sufficiently easier change

[#10032]: pallet_revive: when a dry run simulates contract deployment, return the execution result data.

Fixes paritytech/contract-issues#177

Expose the deployed contract's runtime bytecode in eth_call responses during simulated contract creation.

The test from issue paritytech/contract-issues#177 sends an eth_call request without a destination address, while providing contract bytecode in the data field. This simulates a contract creation transaction. The test expects the RPC response to return the result of executing the init code, which is the deployed contract's runtime bytecode. While this result is not returned in actual deployments, it is expected in dry-run simulations.

[#9823]: bugfix revm set_storage gas cost

Fixes bug in revm gasmetering where the initial charge was less than the adjusted charge.

[#10300]: Allow running try-runtime checks for all pallets except those in the exclusion list

• Added AllExcept variant in Select enum to exclude try-runtime checks for a given list of pallets
• Added TryRuntimeUpgradeConfig struct for extensible configuration of runtime upgrade testing
• Added Executive::try_runtime_upgrade_with_config() for granular control over which pallets' try_state hooks to execute
• Maintained backwards compatibility: existing Executive::try_runtime_upgrade(checks) function continues to work unchanged
• Updated Westend runtime to use the new config-based API to exclude staking-related pallets (Staking, NominationPools, FastUnstake, DelegatedStaking)
• This change is fully backwards compatible - external runtimes and tools (like try-runtime-cli) do not need to update their code

[#10252]: [pallet-revive] use run_instant_seal_and_finalize in dev-node

Fix finalized block in revive-dev-node with instant-seal

[#10168]: pallet-revive: make contract reverted error message more verbose

Make contract reverted error message more verbose in pallet-revive

[#9663]: Add collator selection to YAP

The collator selection pallet as well as other pallets needed for its functionality are added to the Yet Another Parachain runtime.
The YAP runtime is a refactored to adopt the latest FRAME and Substrate changes.

[#9430]: Replace log with tracing on Bridge Relay related modules

This PR replaces log with tracing instrumentation on Bridge Relay related modules by providing structured logging.

[#8381]: Introduce pallet-multi-asset-bounties

This PR introduces pallet-multi-asset-bounties, which enables bounties to be funded by assets other than the native token and adds several key enhancements to bounty management.

The motivation for creating this pallet is to support stablecoin funding in order to mitigate volatility in bounty value and reduce curator overhead.

See the pallet docs for more info about the pallet.

[#10337]: Allow DT CI to be manually triggered

Description

This is a small PR that allows for the differential testing job to be manually triggered instead of only being triggered by PRs.

[#10106]: Enforce single-state txpool for revive-dev-node

Use single-state txpool for dev-node when instant-seal is selected

see #10104

[#10100]: pallet_revive: Only enforce EIP-3607 for dispatchables

The EIP states that contract addresses cannot be the origin of a transaction. However, we are enforcing this rule for all contract execution (i.e all public function on the pallet). This is a problem for code that uses pallet_revive and explicitly wants to allow this.

This PR now only enforces this check for dispatchables so that all the bare_* functions are unaffected.

As a drive-by a regrouped the functions on the Pallet so that the public functions are no longer interleaved with the private ones. This got mixed up when we resolved some merge conflicts.

[#10249]: remote-externalities: Remove old code

The underlying issue was solved by now.

[#9683]: [pallet-revive] add account_id and new_balance_with_dust runtime APIs

Adds two new runtime APIs to the ReviveApi: account_id (which maps an eth address to a substrate account id)
and new_balance_with_dust (which constructs the substrate components of a balance: the real balance, including ED, and the dust,
according to the runtime's configuration).

[#9557]: [pallet-revive] Update genesis config

Update pallet-revive Genesis config
Make it possible to define accounts (contracts or EOA) that we want to setup at Genesis

[#9745]: Avoid double counting PoV size when enqueing XCMP message

Related to #9641

Avoid double counting PoV size when enqueing XCMP message

[#9759]: Add set_storage set_storage_var_key methods

Adds pallet revive methods for manipulating a contracts storage.

Fixes: paritytech/foundry-polkadot#275

[#8106]: Snowbridge V2: Add generic AggregateMessageOrigin

Description

This PR introduces a generic AggregateMessageOrigin in Snowbridge V2 to provide a more flexible mechanism for message-queue origin recognition and handling. This approach aims to support broader use cases beyond parachains. By enabling custom origins, scenarios like solo chains, can build specialized message routing and processing making use of this configuration.

Motivation

• Enhanced Integration: While Snowbridge traditionally focuses on bridging parachains, there is also a need to send messages from various substrate-based chains (e.g., solo chains) and in different contexts. This change expands the protocol's ability to handle multiple, distinct origin types.

• Custom Command Structures: Some projects need to incorporate custom Snowbridge commands or message structures, which cannot be processed by the default outbound queue. By introducing a more generic origin, these commands can be cleanly differentiated and securely processed.

• Flexibility: Parachains, solo chains, or any environment running Snowbridge benefit from a uniform pattern to handle both common and custom message processing.

Use Case

Consider a scenario where you need to send messages to Ethereum directly from your runtime:

• You have your own set of commands or data structures different from those provided by the traditional Snowbridge outbound queue.
• You want to introduce a custom message processor that specifically handles your commands.
• You need a distinct origin to differentiate your messages from standard Snowbridge traffic.

By using the AggregateMessageOrigin, you can verify whether a message comes from a parachain, from Snowbridge itself, or from a custom origin. This is especially relevant in solo chain contexts, where you might not rely on the parachain assumptions but still want to leverage a robust bridging framework.

[#9967]: Remove the experimental-ump-signals feature

Enable UMP signals by default.

[#9811]: Elastic scaling runtime upgrade tests

Add runtime upgrade tests for sync and async backing chains

[#9968]: Return unified gas for gas_left syscalls and opcodes

In #9803 we introduced the new gas mapping. However, when contracts are querying the remaining gas we still returned the ref_time. This PR changes that.

Changes

• Added a new Stack::gas_left function that calculates the remaining gas as eth gas that matches the gas passed in the transaction. It supports both the eth_ and non eth_ flavors of dispatchables.
• Changed the PVM syscall ref_time_left to return the new unified gas.
• Changes the EVM GAS opcode to return the new unified gas
• When calculating the consumed storage we now take into account what was charged during the current frame
• Removed storage_deposit_limit from eth_* dispatchables. It is always uncapped in this case and the overall limit is conveyed using the tx credit.

Follow ups

Now that we can return the proper remaining gas that also includes the storage deposit we can change the EVM call instruction next to take the passed gas into account. Since the unified gas takes both the txfee and the deposit into account it will be able to limit both effectively.

[#9173]: Add abstraction for remotely executing asset transfers on another chain via XCM V5

This PR implements the Transfer abstraction and an implementation thereof, allowing to transfer funds remotely on another chain via XCM V5 on behalf of the account's remote representation on the other chain. Closes #9170. It also extracts code from the existing PayOverXcm trait, as this is essentially only a specialication of the TransferOverXcm abstraction introduced in this PR.

This is based on an implementation in the runtimes' repository, which shows how that would be used in practice. The main users of this abstraction will be pallets that manage multiple accounts on another chain.

[#9510]: Snowbridge: Refactor inbound message conversion

Refactor MessageToXcm inbound converter to make it more compact and organized,
update runtime configuration accordingly

[#9991]: [pallet-revive] fix exp overflow

Update arithmetic tests, and fix potential overflow

[#9841]: replace forloop solc fixture type with test-case macro

For all tests of revm instructions replaced for fixture_type with test-case macro

[#10267]: pallet-revive: add secp256r1 (0x100) precompile

Add secp256r1 precompile (0x100)

[#10153]: [pallet-transaction-storage] Improved check_proof check + tests + docs

This PR:

• Fixes check_proof and its binary_search_by_key chunk
• Adds the verify_chunk_proof_works test, which covers all possible chunk index build/verify proof roundtrips (to catch all corner cases)
• Improves docs around pallet-transaction-storage

[#9961]: Introduce SlotSchedule runtime api

This pull requests introduces the SlotSchedule runtime api. This runtime api will be used in the future to determine the number of parachains blocks to produce per relay chain slot. Right now the pull request only introduces the runtime api and implements it for the parachain runtimes.

Closes: #8905

[#9983]: Fix utility::force_batch returning incorrect weights causing mismatch

The returned weights from the pallet_utility::force_batch dispatch was using batch weights instead of the force_batch weight causing a invalid weight being returned. Now it returns the correct weight.

[#10024]: Bump AH westend spec version

Update spec version of westend AH

[#9865]: [pallet-revive] rm checked-in metadata

Removed eth-rpc generated metadata.
The metadata file will now be generated from the build.rs using the AH-westend runtime

[#9644]: Update kvdb-rocksdb to v0.20.0

Related to paritytech/parity-common#932

[#9826]: Update pallet-asset-rewards to use BlockNumberProvider

This updates pallet-asset-rewards to use BlockNumberProvider trait instead of directly
using the system block number.
This change enables the pallet to be used in parachain enviroments where block numbers
may come from different sources(i.e. Relay chain).

Runtimes using this pallet must now implement the BlockNumberProvider type.
For most cases setting the type BlockNumber = frame_system::Pallet<Self>; will maintain
the previous behaviour.

[#10008]: Add instant seal to omni-node

Adds a new --instant-seal CLI flag to enable instant seal mode in omni-node. When this flag
is passed, blocks are produced immediately upon receiving transactions, rather than at fixed
intervals. This flag cannot be used together with --dev-block-time.

fixes #9996

[#10271]: fix NextFeeMultiplier update before Revive::on_finalize

Fix #10177

Store base_fee_per_gas and block_gas_limit in the EthBlockBuilderIR, since these values are derived from the NextFeeMultiplier and we can't read it from Revive::on_finalize since this runs (in most Runtime) after TransactionPayment::on_finalize where the value is updated for the next block.

also use BlockNumberFor<T> for the BlockHash map instead of U256. No release have been performed yet since the introduction of that change, so that should not require any migration.

	#[pallet::storage]
	pub(crate) type BlockHash<T: Config> =
		StorageMap<_, Identity, BlockNumberFor<T>, H256, ValueQuery>;

[#9588]: [XCMP] Add support for double encoded XCMs

This PR adds support for receiving double encoded XCMs via XCMP.

Right now parachains pass XCM messages between them through XCMP pages that use the XcmpMessageFormat::ConcatenatedVersionedXcm format. These pages contain concatenated encoded VersionedXcms and on the receiving side, in order to split the page into individual messages, we need to first decode them and then re-encode and forward them to the pallet-messages-queue. This adds extra overhead (about 2.5 microseconds + some cost per byte).

This PR adds a new (XcmpMessageFormat::ConcatenatedOpaqueVersionedXcm) format that will be used for pages with double-encoded XCMs. This makes the decoding much easier and almost free, improving the XCMP bandwidth.

This new format is never used for sending for the moment. We'll have to come out with a roll-out plan later.
For the moment it's important to add the support for receiving XcmpMessageFormat::ConcatenatedOpaqueVersionedXcm and to let it propagate to as many parachains as possible as they update the runtime.

[#10102]: Use Config::XcmExecutor inside dry_run_xcm.

Refactors the dry_run_xcm implementation in pallet-xcm to use the runtime's configured Config::XcmExecutor type.
Enabling consistent behaviour for runtimes which use custom XCM executors.

[#9627]: Improve inbound_queue::BenchmarkHelper to add more flexibility

Description

Improve the usage of the inbound_queue::BenchmarkHelper to decouple the mocks from the benchmark.
This change will enable any user to benchmark custom messages since now it's harcoded to the register_token_message only

[#9892]: Improve asset conversion

Add view function for pallet-asset-conversion.
Add trait MutateLiquidity for pallet-asset-conversion.

[#10000]: try state hook for alliance pallet

This PR introduces the try_state hook to pallet-alliance to verify key storage invariants.

[#9204]: Snowbridge: Refactor with Alloy primitives and clean up code

Refactor with Alloy primitives and clean up code.

[#9517]: [pallet-revive] Migrate various getters to System pre-compile

Migrates own_code_hash, caller_is_origin, caller_is_root, weight_left, minimum_balance. Contains minor other fixes (removing leftovers from deprecating chain extensions, stabilizing block_hash in overlooked crates, …).

[#9705]: [pallet-revive] Properly convert Ext::minimum_balance value to U256

The value returned by minimum_balance was just cast into U256,
without applying the actual conversion factor (NativeToEthRatio).

[#9780]: [pallet_transaction_payment]: Share withdrawn tx fee credit with other pallets

Replaces #9590.

The audit of #9590 showed that holding the txfee as held balance and especially playing around with providers causes a lot of troubles.

This PR is a much lighter change. It keeps the original withdraw/deposit pattern. It simply stores the withdrawn Credit and allows other pallets to withdraw from it.

It is also better in terms of performance since all tx signers share a single storage item (instead of a named hold per account).

[#9798]: Introduce unapplied_slashes_v2 Runtime API

Adds a new unapplied_slashes_v2 runtime API in v15 but keeps
old unapplied_slashes API and type for backwards compat.

[#9928]: pallet-revive: Bump PolkaVM

Bumped polkavm to the latest version. No semantic changes in that update.

[#9939]: [pallet-revive] dev-node constant fee multiplier

This will let us have stable gas cost (as long as the state of the dev net does not change)

In mainnet you can't rely on stable gas anyway since the state of the blockchain can change between two dry runs,
but we are probably better off if we have stable gas cost in testing environments.

[#10080]: precompiles: Enforce state mutability

pallet-assets-precompile, pallet-xcm-precompiles and revive builtin precompile implementations currently violate Solidity state mutability, potentially introducing a new attack vector. This PR implements corresponding checks at the function dispatch.

Could be enforced in pallet-revive, however:

1. Adding something like a const MUTATES: bool to the Precompile trait won't help because whether the call is mutating or not depends on the Solidity function selector..
2. Alloy, which we are using to parse the interface definitions prior to calling precompile implementations, doesn't provide a mapping from function selector to its mutability modifier.

[#10120]: [revive] Receipts should include failed tx

Fix Eth block receipt production, the current approach didn't work as failed extrinsic, revert all storage changes.
This PR updates eth transactions, so that they always succeed, the logic is wrapped into a top level with_transaction that will rollback all storage change in case of failure

[#10151]: Adjustable zstd compression level

Changes:

• Create compress_weakly, compress_strongly and compress_with_level functions for variable compression levels
• Use said functions instead of the old fixed-level compress function
• Deprecate compress function in faviour of the added ones

[#9885]: Omni-node: Manual-seal uses proper aura digests

Omni-node in dev mode is now operating closer to reality. The runtime is supplied with appropriate AURA digests.
Breaking changes:

• sc-consensus-manual-seal: The trait bounds have been relaxed, it should be easier to accomodate now. Code might break since the generics changed.
• polkadot-omni-node-lib: DynNodeSpecExt trait has been removed and can no longer be used. Implementers of the NodeSpec trait now need to provide an implementation for starting a dev node.

[#9744]: [pallet-revive] fix CodeInfo owner

Fix CodeInfo owner, it should always be set to the origin of the transaction

[#10065]: eth-rpc add trace logs

Add extra tracing logs for estimate_gas and send_raw_transaction

[#9385]: Rve/revm instructions bitwise WIP

Extend EVM support for pallet_revive with the follow instructions:

• arithmetic
• bitwise
• control
• host
• memory
• stack

[#10281]: [pallet-revive] improve eth-rpc tests reliability

Improve eth-rpc tests reliability by replacing substrate-node with revive-dev-node, fixing nonce query in runtime_api_dry_run_addr, and running all tests in a single tokio test function

[#9987]: [pallet-revive] turn on allowEvmByteCode

turn on AllowEVMBytecode for westend AH

We can probably get rid of this config as well now

[#9887]: Rve/9565 pallet revive evm backend ensure memory dos safety2

fixes #9565

[#9717]: EIP-3607 added check to make sure a contract account cannot transfer funds as an EOA account

fixes #9570

[#9732]: Remove the deprecated CheckInherents logic

This removes the CheckInherents logic from register_validate_block, instead the ConsensusHook should be used to verify certain data.

Besides that it also changes the how validate_block verifies the ValidationData passed by the collator. Instead of extracting the ValidationData before executing the block, the validation data is now checked as part of the pallet logic.

[#10192]: revive: Fix dust & child contract calls

When transferring to self we should just return early as it's a noop.
Not doing so cause bug in transfer_with_dust

as we do

from.dust -= from.dust
to.dust += to.dust

We end up with a value of dust - planck (that we burnt from to create dust amount) on the account

fix paritytech/contract-issues#211

[#10224]: make contracts create consider is_unlimited_contract_size_allowed

While running foundry tests from https://github.com/balancer/balancer-v3-monorepo/tree/main/pkg/pool-weighted, found we hit this limit.

Foundry environment is configured with unlimited code size, so we need to make sure pallet-revive respects those configurations everywhere.

[#9603]: [pallet-revive] Migrate unstable storage host functions to Storage pre-compile

Migrates the unstable host functions contains_storage, take_storage, and clear_storage to a new Storage pre-compile.

[#9803]: Rework gas mapping

Did some breaking changes to the Config trait and impl_runtime_apis_plus_revive macro.
Config::Balance: Set to the runtimes balance typ
Config::FeeInfo: Set to pallet_revive::evm::fees::Info<Address, Signature, EthExtraImpl>Renamedimpl_runtime_apis_plus_revivetoimpl_runtime_apis_plus_revive_traits` and added
another parameter (set to the name of the revive Pallet "Revive").

[#9638]: Deprecate OnRuntimeUpgrade parameter in frame_executive::Executive struct.

Deprecate OnRuntimeUpgrade parameter in frame_executive::Executive struct.

[#9699]: Rve/revm selfdestruct2

fixes #9621

Behavior of terminate is changed in accordance with EIP-6780 (and EVM in general):

• terminate only deletes the code from storage if it is called in the same transaction the contract was created.
• terminate does not destroy the contract instantly. The contract is registered for destruction, which happens at the end of the transaction.

[#10205]: Run differential tests for PolkaVM and REVM

Description

This is a PR that builds on PR #10071 making the differential testing framework run the tests for both REVM and PolkaVM.

[#10213]: Increase the concurrency of retester in CI

Description

This PR bumps the commit hash of the revive differential tests repo allowing us to pull in some tests that needed to be fixed. Additionally, it increases the concurrency of retester to allow it to run the tests faster

[#10113]: weights: fix adding weights

• Fixes potential integer overflow in CheckWeight::check_extrinsic_weight() by
  adding saturating arithmetic methods to Weight:
  • saturating_add_ref_time(),
  • saturating_sub_ref_time(),
  • saturating_add_proof_size(),
  • saturating_sub_proof_size()
• Includes test cases for extreme values
• Improves debug logging.

[#9818]: [pallet-revive] revm refactor

This PR refactors the REVM implementation in pallet-revive, reducing technical debt and decoupling it from specific REVM versions. This enables easier integration with other projects, such as Foundry, with dependencies limited to REVM's Bytecode.

Background:
Many of REVM's generics and trait abstractions were unused or ignored to avoid bugs. The pallet interacts with the host via the Ext trait, rendering other REVM abstractions unnecessary.

Previously unused REVM components included:

• Host trait: Unused, relied on the DummyHost mock.
• Gas field: Not used, as the pallet uses its own accounting.
• Methods from InputsTr: Most methods unused or had panic implementations.
• Spec: Only maintaining the latest fork per runtime.

Key Changes:

• Interpreter: Now a minimal struct with only necessary fields.
• Stack: Uses sp_core::U256 for better integration.
• Memory: Simplified to needed methods only.
• Instructions: Rewritten with simple signatures, using match statements instead of function pointer tables. Gas charging uses EVMGas wrapped in Token<T>. The interpreter loop has been significantly simplified.
• Error Handling: Failed opcodes now return Halt::Err(DispatchError), removing previous error conversions.

[#10313]: Increase max_upward_message_size in RelayStateSproofBuilder

Description

While testing different XCM messages via xcm-emulator, I noticed that the limit of 256 for max_upward_message_size in RelayStateSproofBuilder can be reached very easily.

I suggest increasing it to 1024 * 1024 so that we can have a good range for testing.

[#10157]: pallet_revive: Improve logging

Just added some more information to the log output during dry_run and transaction creation. This was helpful when debugging if the correct gas was passed in by the client.

[#10041]: added baltathar, charleth, dorothy, and ethan to eth-rpc and revive-d…

adds more funded accounts to eth-rpc and dev-node

[#9295]: MMR: add ancestry proof generation runtime method and RPC call

This PR adds the generate_ancestry_proof to MmrApi and bumps the
MmrApi version from 2 to 3.
Removes the related generate_ancestry_proof method of BeefyApi;
mmr::MmrAPI::generate_ancestry_proof should be used instead.

[#10016]: [pallet-revive] fix subxt submit & add debug statments

• Fix subxt submit by default it's using author_submitAndWatchExtrinsic even though we just want to fire and forget
• Add debug instructions to log the signer & nonce of new eth transactions when the node validate the transaction

Changelog for Node Operator

ℹ️ These changes are relevant to: Those who don't write any code and only run code.

[#9936]: Additional invulnerable AssetHub collators for Polkadot and Kusama

Update the list of invlunerable AssetHub collators for Polkadot and Kusama

[#10263]: slot-based collator: Spawn internal futures as essential tasks

It is required launch them as an initial task to bring down the node if one of them stopped.

[#9417]: Measure backed in block count vs backable

Added a mechanism to measure the difference between the number of candidates
backed on chain versus offchain from the perspective of the node.

[#10333]: parachain-consensus: Do not pin blocks on the relay chain during syncing

The parachain-consensus component in parachain nodes was hogging finality notifications. This is now fixed.
The finality notifications where keeping blocks pinned in memory, causing unnecessary memory usage.

[#10202]: omni-node: Enable storage monitor

The storage monitor shuts down the node when the available DB space is falling below a configured minimum (1GB by default). This prevents that a database gets corrupted when a disk is filling up.

[#10179]: TxPool: Downgrade log from info to debug

There is no need to log information about maintain to the info log.

Changelog for Runtime User

ℹ️ These changes are relevant to: Anyone using the runtime. This can be a token holder or a dev writing a front end for a chain.

[#9842]: xcm: Do not require Asset to be sorted on decode

Asset was requiring that all the assets are sorted at decoding. This is quite confusing for people writingg frontends, because this is not really documented anywhere. There are also only at max 20 assets available, we can just make everyones life easier and always sort the assets after decoding.

[#10089]: pallet_revive: Raise the MaxEthExtrinsicWeight

Fixes paritytech/contract-issues#194

Factory extrinsics do need more weight. It is fine to raise them to almost the full max extrinsic weight since this is still lower than the block weight.

Also improving the error reporting during the dry run in case an extrinsic hits this limit. No more OutOfGas but a more descriptive error of how much it is overweight.

[#10191]: pallet_revive: Add dry-run timestamp override support

Description

This PR updates pallet-revive to support overriding the block timestamp during dry-run calls.
The dry-run execution now uses the following configuration for eth_estimateGas and eth_call when the block tag is pending:

block.timestamp = max(rpc_timestamp, latest_block.timestamp + 1)
block.number = latest_block.number + 1

Fixes #153, #205

Integration

Downstream projects using the ReviveApi::eth_transact runtime API should either provide a timestamp or pass None.

Review Notes

• Added dry run timestamp to ExecConfig.
• Added a new parameter to ReviveApi::eth_transact for passing the current RPC timestamp.
• eth_estimateGas defaults to the pending block tag.
• eth_estimateGas and eth_call with pending block tag will dry run the transaction with the block timestamp set to max(rpc_timestamp, latest_block.timestamp + 1) and block number set to latest_block.number + 1.

[#9911]: [pallet-revive] Allows setting evm balance for non-existing account

Allows calling set_evm_balance for a non-existing account on pallet-revive.

[#10027]: pallet_revive: Lower the deposit costs for child trie items

Fixes #9246

[#10047]: pallet_revive: Increase event sizes

Fixes paritytech/contract-issues#140

This increases the maximum event payload size from 416 bytes to 64k. Since #9418 we charge some additional weight per byte of event payload. This makes it possible to raise the limit while staying within our memory envelope. This artificial weight will add 18us of weight to a maximum sized event.

[#10214]: pallet_revive: Fix EVM tests to pass data as part of code

The test code was passing the constructor argument as data on EVM. But it should be passed as part of the code. This is different from PVM where those are separate.

Failing to do so makes those opcodes return the wrong values when data is passed to the constructor:

CODESIZE
CODECOPY
CALLDATASIZE
CALLDATACOPY
CALLDATALOAD

Further changes:

• I also added some checks to fail instantiation if data is non empty when uploading new EVM bytecode.
• Return error when trying to construct EVM contract from code hash as this does not make sense since no initcode is stored on-chain.

[#10126]: pallet-salary: Fix unpayable registrations from previous cycles

Fixes a bug in fellowship salary where users who registered for payout in cycle N
but missed the payout window would be unable to claim payment in subsequent cycles.

[#10160]: pallet_revive_dev_node: Always increment the timestamp by at least one second

Fixes paritytech/contract-issues#191

The instant seal introduces a race condition. Blocks can be build faster than the timestamp resolution of Ethereum. Eth timestamps are only one second granularity. If we build blocks faster it can happen that the timestamp delta between them is zero. This is not allowed. We have to make sure that in instant seal two blocks don't return the same timestamp.

This PR does that by always incrementing the timestamp by at least one second. Note that this is a dev-node only change. Production chains won't have this problem as long as the block time is larger than 1 second.

Yes, it will produce timestamps in the future. But this seems to be the lesser evil for this dev node. Time is subjective. But the rule to not return duplicate timestamps is dependent on.

[#9173]: Add abstraction for remotely executing asset transfers on another chain via XCM V5

This PR implements the Transfer abstraction and an implementation thereof, allowing to transfer funds remotely on another chain via XCM V5 on behalf of the account's remote representation on the other chain. Closes #9170. It also extracts code from the existing PayOverXcm trait, as this is essentially only a specialication of the TransferOverXcm abstraction introduced in this PR.

This is based on an implementation in the runtimes' repository, which shows how that would be used in practice. The main users of this abstraction will be pallets that manage multiple accounts on another chain.

[#9617]: [pallet-revive] Add setting evm balance

Adds a balance setter in EVM for pallet-revive.

[#9892]: Improve asset conversion

Add view function for pallet-asset-conversion.
Add trait MutateLiquidity for pallet-asset-conversion.

[#9885]: Omni-node: Manual-seal uses proper aura digests

Omni-node in dev mode is now operating closer to reality. The runtime is supplied with appropriate AURA digests.
Breaking changes:

• sc-consensus-manual-seal: The trait bounds have been relaxed, it should be easier to accomodate now. Code might break since the generics changed.
• polkadot-omni-node-lib: DynNodeSpecExt trait has been removed and can no longer be used. Implementers of the NodeSpec trait now need to provide an implementation for starting a dev node.

[#10026]: pallet_revive: Fix incorrect block.gaslimit

Fixes paritytech/contract-issues#112

[#9803]: Rework gas mapping

Fixes those InvalidTransaction errors. Gas mapping is now works even when the wallet does tamper
with the weight estimate.

[#10243]: pallet-xcm: API changes to use VersionedAssetId instead of u32 to specify asset for fees

Multiple pallet-xcm calls use u32 index as a way to specify which asset from the assets (also an arg of the call) is to be used for fees purposes. This PR brings major API change (breaking change) that proposes usage of VersionedAssetId instead

Affected pallet-xcm calls: teleport_assets, reserve_transfer_assets, limited_reserve_transfer_assets, limited_teleport_assets, transfer_assets

This is follow-up change to the: #9842, that aims to remove the requirement of the client to provide sorted list of Assets to the APIs (often a point failures). With the mentioned change sorting happens on the runtime side and u32 index (provided by the client) can become invalid after sorting (this PR aims that problem)

Relevant dicussion on XCM public element channel

[#9645]: Extended AppSignature trait with Signature

Extended sp_application_crypto::AppSignature trait with sp_core::crypto::Signature.

[#9942]: pallet-revive: Fix dry run balance check logic

Fix fault balance check logic during dry-run:

We should not enforce that the sender has enough balance for the fees in case no gas is supplied.

cc @TorstenStueber

Rust compiler versions

This release was built and tested against the following versions of rustc.
Other versions may work.

• Rust Stable: 1.88.0

Runtimes

The information about the runtimes included in this release can be found below.
The runtimes have been built using srtool v0.18.3 and rustc 1.88.0 (6b00bc388 2025-06-23).

Westend

🏋️ Runtime Size:          1.83 MB (1921122 bytes)
🔥 Core Version:          westend-1021000 (parity-westend-0.tx27.au2)
🗜 Compressed:            Yes: 80.9%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0xa6b8704ee1570ec5a50496afdf7d33059ea1bcb7776df090df0eef12d553643e
🗳️ authorizeUpgrade hash: 0xc4c452307271e4f843aa9cb162030fdc44879c5939fc0ac5a99c48958d93d51e
🗳️ Blake2-256 hash:       0xee7207f9180e933d615118612cdb9526dff9dae71f814cffa738c2cfa86f2f1a
📦 IPFS:                  QmTVdvPQnsfJfsdYTuWQyLf7BmZnfLkDA61JRqYkoBCujT

Westend Assethub

🏋️ Runtime Size:          2.26 MB (2372916 bytes)
🔥 Core Version:          westmint-1021000 (westmint-0.tx16.au1)
🗜 Compressed:            Yes: 82.04%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0x89dbfe5dc0d6aa451fe04a322316505d5ac8dcb7dc9f49860c4879f99c744533
🗳️ authorizeUpgrade hash: 0x4fe5ffd9f4f17ad9bcf9e0b50dbfbae1b716156e474892ba878b51848b6dbadd
🗳️ Blake2-256 hash:       0xc99ca3b73470f5c0c691ecd87e753a1d28d562392d2bdd548dc61b3fd2509f93
📦 IPFS:                  QmXbxGtPow8zcZWhKLF6ykgFXUBHvHhrkmiRW1fdjPwGUi

Westend Bridgehub

🏋️ Runtime Size:          1.34 MB (1405004 bytes)
🔥 Core Version:          bridge-hub-westend-1021000 (bridge-hub-westend-0.tx6.au1)
🗜 Compressed:            Yes: 80%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0x7210e626277ad71b1bf943fe210bb1875a32899058867c9e39539f1e7b9efbe9
🗳️ authorizeUpgrade hash: 0xac7e610f80ff31088ed515ac19039389228c7dc712c6ff3ef360e0b944eea2c5
🗳️ Blake2-256 hash:       0x0c87b49ee6545927387aedc4e1a843b5c2729999cbb0e8eb8aa8a8bc7acf7f44
📦 IPFS:                  QmenQqkB9kFXG1XkuBMdqPX7h5f27GB2nJMTeWosQzWzHj

Westend Collectives

🏋️ Runtime Size:          1.21 MB (1270135 bytes)
🔥 Core Version:          collectives-westend-1021000 (collectives-westend-0.tx6.au1)
🗜 Compressed:            Yes: 80.97%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0x551337b3424633d736a78ae963bc74c1631b6bf31484eeea86891e3af263084e
🗳️ authorizeUpgrade hash: 0xee74eee8198046c715e42621497b4558d2449502f8ab4b81eb9d1770db4eb2e0
🗳️ Blake2-256 hash:       0x32cea8b2a2f366daa3f8f1f6b6edeeb8031743f52333597260cd91e284aabd1a
📦 IPFS:                  QmcBs1MasuaAELBmD8aB1ZddB46hzUBg9pZv2LYzK8tyxD

Westend Coretime

🏋️ Runtime Size:          1.08 MB (1130559 bytes)
🔥 Core Version:          coretime-westend-1021000 (coretime-westend-0.tx2.au1)
🗜 Compressed:            Yes: 79.94%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0x9a40efe86e7e28bfb2497c0d98ba0540c7042283df886eb5bd684abb56bfca78
🗳️ authorizeUpgrade hash: 0x8493bf093c8815ff2185154cdce4d2c87166f536d18bd8a6e186e0d44f32d699
🗳️ Blake2-256 hash:       0x2a9cc8b081f24b0c2878c037b5905aae6a13112799dc0ccbc48c02a5f1c0f52d
📦 IPFS:                  Qmaub6smjmgXriShKuYP965TUoJ1HjfJo2KLHMfSKM5GXu

Westend Glutton

🏋️ Runtime Size:          536.27 kB (549144 bytes)
🔥 Core Version:          glutton-westend-1021000 (glutton-westend-0.tx1.au1)
🗜 Compressed:            Yes: 78.05%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0xe16cc7758f338207a6fc791d2b212b548be591b28ba18c34e228a1bee8256268
🗳️ authorizeUpgrade hash: 0xdd354e524a02e57e1aa1ece23b27ffb3eece8ee1588192ee1b35b277acc7b0ee
🗳️ Blake2-256 hash:       0x0c5958377462a56044631535d1561bd1405ffa3809dfbd978e2ef2b78bee481d
📦 IPFS:                  QmYr3ywQETwDqnt6jQi7jWnCZFv9y1pH6hp5VYSqJwk27y

Westend People

🏋️ Runtime Size:          1.07 MB (1122483 bytes)
🔥 Core Version:          people-westend-1021000 (people-westend-0.tx2.au1)
🗜 Compressed:            Yes: 79.92%
🎁 Metadata version:      V14
🗳️ system.setCode hash:   0x32271be528948ded81b3d3ff0457d41440e2ed7aa62dbdd68b08d757009abf7f
🗳️ authorizeUpgrade hash: 0xdd3da9c74e92cd0476fb6066a9d0145edbbf718e6ba638bf3c38fc9373711e06
🗳️ Blake2-256 hash:       0x0020598446cab99d18a91cb9d4765fcdc15b429a98223e414fcce702a210ae73
📦 IPFS:                  QmTKx7vfz35BVbnKfrEMEmDDdiaaS51nDzfhzERNBpUfqi

Docker images

The docker images for the polkadot node binary and the polkadot-parachain binary can be found at Docker hub (will be available a few minutes after the release has been published):

• Polkadot image
• Polkadot-Parachain image

You may also pull it with:

docker pull parity/polkadot:stable2512-rc1

or

docker pull parity/polkadot-parachain:stable2512-rc1