Differences from Ethereum

Plume is built on the Arbitrum Nitro stack—the same stack that powers all Arbitrum chains, including Arbitrum One and Arbitrum Nova. The Arbitrum Nitro stack aims to maintain a high level of compatibility and consistency with Ethereum, so in general, you should be able to deploy your contracts from Ethereum and other EVM-compatible chains directly on Plume with no modifications. This page details the remaining minor differences.

Plume Specific Differences

The Plume mainnet will have slight modifications to Arbitrum Nitro's state transition function compared to other chains. Specifically, we are optimizing the execution client to more efficiently execute certain operations that are more commonly used when dealing with real world assets. The end result is that we can reduce gas costs on these operations, making them much cheaper for the end user given how frequently they are being called.

The first functions with reduced gas costs are the functions to get attestations from the Ethereum Attestation Service (EAS). We are deploying the EAS attestation and schema registry contracts as predeploys, a feature of Optimism that is not available in Arbitrum. This allows dapp developers to build applications that comply with identity verification and anti-money laundering requirements, without spending a burdensome level of gas.

Solidity Differences

Starting from Solidity version 0.8.20, the Solidity compiler generates bytecode containing the new PUSH0 opcode, introduced by EIP-3855 and included in the Ethereum Shanghai upgrade. However, the Arbitrum Nitro stack does not yet support this opcode, so contracts compiled on 0.8.20 or above on the Shanghai EVM cannot be deployed to Plume.

The solution is to either change the EVM target to the previous Paris EVM version, or to set the Solidity compiler version to 0.8.19, in which case some common dependencies may also have to be downgraded. For example, OpenZeppelin version 5.0.0 increased the minimum Solidity compiler version to 0.8.20, so the latest version compatible with earlier compiler versions would be OpenZeppelin version 4.9.5.

The following properties also return different values on Plume compared to Ethereum:

  • blockhash()

  • block.coinbase

  • block.diffiulty

  • block.prevrandao

  • block.number

  • msg.sender

See "Solidity Support" in the official Arbitrum documentation for more details.

Block Numbers

Blocks on the Plume network have their own L2 block numbers, which are independent from Ethereum block numbers. For example, one Ethereum block can contain multiple Plume blocks, although one Plume block can only be in a single Ethereum block.

Plume block numbers start at 0 for the genesis block and increase sequentially as transactions go through the sequencer. If there are no transactions on the Plume network, then no Plume blocks will be created. An approximation to the current L1 block number can be accessed using block.number in Solidity. The current Plume block number can be accessed using the ArbSys precompile:

ArbSys(100).arbBlockNumber()

See "Block Numbers and Time" in the official Arbitrum documentation for more details.

RPC Methods

Most RPC methods on Plume behave like on Ethereum, but some methods have slightly different outputs or add additional Plume-specific information, including but not limited to:

  • eth_getTransactionByHash

  • eth_getTransactionReceipt

  • eth_getBlockByHash

  • eth_syncing

See "RPC Methods" in the official Arbitrum documentation for more details.

L2 Rollup Specific Features

There are some additional features on Plume specific to L2 rollups and the Arbitrum Nitro stack:

PreviousSmart Contract VerificationNextAsset Tokenization

Last updated