EVM Compatibility
Orbinum runs the EVM through Frontier inside a Substrate runtime. Solidity contracts deploy unmodified and Ethereum tooling connects over the standard JSON-RPC. This page lists every behaviour that differs from Ethereum mainnet.
Execution rules
The EVM runs the Pectra rule set. Contracts compiled for prague deploy as they are, and
PUSH0, transient storage (EIP-1153) and MCOPY are available.
| Transaction type | Supported |
|---|---|
| Legacy, EIP-2930, EIP-1559 | Yes |
| EIP-7702 (set code) | Yes |
| EIP-4844 (blob) | No; the chain has no blobs |
A legacy transaction must carry an EIP-155 chain ID. The runtime refuses one without it
(AllowUnprotectedTxs = false), whether it arrives over JSON-RPC or as an extrinsic, so a
transaction signed for another chain cannot be replayed on Orbinum.
Accounts
An EVM address H160 is the Substrate account AccountId32 formed by the 20 address bytes
followed by 12 zero bytes, so one key and one balance serve both sides. See
EVM ↔ Substrate Mapping.
Fees
| Part | Where it goes |
|---|---|
| Base fee | Burned |
| Priority tip | The validator account that authored the block |
| Tip with no block author | Burned, for example in an RPC simulation |
The base fee follows EIP-1559 and starts at 1 gwei at genesis. Read the current value with
eth_gasPrice or eth_feeHistory.
Substrate extrinsics are priced like EVM gas: an extrinsic costs what the same weight would cost as gas at the default base fee. The rates are in Chain constants.
block.coinbase
block.coinbase, and miner in eth_getBlockByNumber, is the zero address
0x0000000000000000000000000000000000000000. A validator is an sr25519 account with no EVM
address, so any other value would name an account nobody controls. A contract cannot use
block.coinbase to identify or pay the block producer.
Gas
| Limit | Value |
|---|---|
| Block gas limit | 75,000,000 |
| Transaction gas limit | 2²⁴ = 16,777,216 (EIP-7825, TransactionGasLimit). A transaction asking for more is invalid and never enters the pool |
A transaction is charged the largest of three amounts:
| Amount | How it is computed |
|---|---|
| Execution gas | As on Ethereum |
| Proof-size gas | Bytes of storage proof the transaction reads × 14 |
| Storage-growth gas | Bytes of new storage the transaction writes × 183 |
A transaction that reads or creates a lot of storage can therefore cost more gas than on Ethereum.
eth_estimateGas includes all three; use it rather than hard-coded gas limits.
A gas limit that cannot be converted to a weight limit ends the transaction as OutOfGas, charging
the full gas limit.
Precompiles
The registered addresses are listed in Precompile Addresses:
0x01–0x05, four Frontier precompiles at 0x400–0x403, and Orbinum's ShieldedPool (0x801)
and Balances (0x802).
Modexp (0x05)
Modexp follows EIP-7823 and EIP-7883:
| Rule | Value |
|---|---|
| Input size | A base, exponent or modulus longer than 1,024 bytes fails the call and consumes all its gas |
| Minimum cost | 500 gas |
| Complexity | 16 when the longer of base and modulus is at most 32 bytes; 2 × words² above that |
| Exponent length | Each exponent byte past the first 32 counts 16 in the iteration count |
| Division | None: the cost is complexity × iteration count, not divided by 3 |
Unregistered precompile addresses
These Ethereum precompiles are not registered:
| Address | Ethereum precompile |
|---|---|
0x06, 0x07, 0x08 | BN254 add, scalar multiplication, pairing |
0x09 | BLAKE2F |
0x0a | KZG point evaluation |
0x0b–0x11 | BLS12-381 operations |
0x100 | P256VERIFY (secp256r1) |
A call to an unregistered address does not revert. The EVM treats it as a call to an empty
account: it succeeds and returns no data. A contract that decodes that empty output as a result,
for example a pairing check read as false, fails silently. Check the length of what comes back:
/// Calls a precompile and refuses an empty answer, which is what an unregistered address returns.
function callPrecompile(address precompile, bytes memory input) internal view returns (bytes memory out) {
bool ok;
(ok, out) = precompile.staticcall(input);
require(ok && out.length > 0, "precompile unavailable");
}
Use it for precompiles whose output is never empty.
Orbinum precompiles hold stub code
0x…0400–0x…0403, 0x…0801 and 0x…0802 hold the five-byte stub 0x60006000fd, which never
runs. Without code, a Solidity high-level call to a function that returns nothing would revert at
its code-size check before reaching the precompile; with it, high-level calls work. The Ethereum
precompiles 0x01–0x05 hold no code, as on Ethereum, and Solidity reaches them with staticcall.
No logs from precompiles
Precompiles emit no EVM logs, so a call to one leaves nothing in the receipt's logs or in
eth_getLogs. Their effects appear as Substrate events, such as Balances.Transfer or
ShieldedPool.Shielded. See Indexing Events.
No on-chain verifier for arbitrary proofs
With the BN254 and BLS12-381 precompiles unregistered, a Solidity verifier generated by snarkjs,
or any contract built on pairings, cannot verify proofs on Orbinum. The shielded pool's proofs are
verified natively by the runtime, not by the EVM. The ShieldedPool precompile exposes one
function, shield, which deposits ORB with its shield proof. It is not a general verifier.
Network parameters
Chain IDs, endpoints, the token and the tool configuration are in Network & Tooling.
Related
- Network & Tooling — parameters, endpoints and tool configuration
- Precompile Addresses — every registered address
- Calling a Precompile — how to call Balances and ShieldedPool
- EVM ↔ Substrate Mapping — account mapping
- On-Chain Verification — how the runtime verifies proofs