Plume vs. Ethereum

Plume is an EVM-compatible blockchain, and most smart contract developers will not notice any differences with Ethereum. This page outlines some of the differences between Plume and Ethereum, which are similar to the differences between Arbitrum and Ethereum.

Gas and Fees

There is a fee for executing a transaction on Plume, just like on Ethereum. The difference is that Plume transactions must pay an extra fee to cover the cost of batch posting to Ethereum. More details are available in Gas and Fees.

Block gas limit, numbers, and time

Block gas limit

When submitting a transaction to Plume, users pay for both execution on Plume and the cost of posting calldata to Ethereum. This dual cost structure results in a higher gas limit than pure execution alone. The total gas limit of an Plume block includes all transaction gas limits, accounting for Ethereum data costs. To manage potential cost variations, Ethereum assigns a much larger artificial gas limit, but the actual execution gas limit is capped at 32 million. This discrepancy explains why a block’s reported gas limit may appear inflated despite the effective execution costs.

Block numbers

Plume assigns its own block numbers, distinct from Ethereum’s, with multiple Plume blocks potentially fitting within a single Ethereum block. However, each Plume block is always associated with exactly one Ethereum block. In Plume smart contracts, querying block.number returns a value close to the L1 Ethereum block number when the sequencer received the transaction, though it may not be exact. Timing assumptions based on block numbers are reliable over several hours but not within minutes, similar to Ethereum.

Plume blocks start at 0 from genesis and increase sequentially, with the sequencer determining block transitions based on transaction activity. Blocks are produced as needed, meaning block production may be sporadic during hours of low activity. When querying a Plume node’s RPC, transaction receipts return the Plume block number, with the corresponding Ethereum block number available in the l1BlockNumber field.

Block timestamps

Block timestamps on Plume are determined by the sequencer’s clock and are independent of the timestamp of the Ethereum block. Each Plume block timestamp must be equal to or greater than the previous one and must fall within set boundaries—no more than 24 hours in the past or one hour in the future. Since the sequencer may experience delays in posting batches to Ethereum, it has limited flexibility to adjust timestamps within the defined boundaries to maintain chain stability and prevent reorganization.

RPC methods​

Most of the RPC methods available on Plume behave exactly the same as the methods do on Ethereum. However, some methods may result in a different output or add more information on Plume. These methods behave the same as they do on Arbitrum, so information about the exact differences is available on Arbitrum's documentation of RPC methods.

Solidity Support

Smart contracts on Plume mostly behave the same as they do on Ethereum. However, some properties and functions on Solidity smart contracts return a different result on Plume. The operations that return a different result are the same as Arbitrum's, so more information is available on Arbitrum's documentation of Solidity support.

Cross-chain messaging​

Arbitrary messages can be passed from Ethereum to Plume. These are commonly known as "parent chain to child chain messages". Developers using this functionality should familiarize themselves with how they work. Find more information about it in Parent chain to child chain messaging.

Similarly, Plume can also send messages to Ethereum. Find more information about them in Child chain to parent chain messaging and the outbox.

Precompiles​

Plume supports all precompiles available in both Ethereum and Arbitrum, with methods smart contracts can call the same way they can Solidity functions. You can find a full reference of them in Precompiles.

NodeInterface​

Plume includes a special NodeInterface contract available at address 0xc8 that is only accessible via RPCs (it's not actually deployed on-chain, and thus can't be called by smart contracts). Find more information about this interface in NodeInterface.