Skip to main content

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 typeSupported
Legacy, EIP-2930, EIP-1559Yes
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​

PartWhere it goes
Base feeBurned
Priority tipThe validator account that authored the block
Tip with no block authorBurned, 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​

LimitValue
Block gas limit75,000,000
Transaction gas limit2²⁴ = 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:

AmountHow it is computed
Execution gasAs on Ethereum
Proof-size gasBytes of storage proof the transaction reads × 14
Storage-growth gasBytes 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:

RuleValue
Input sizeA base, exponent or modulus longer than 1,024 bytes fails the call and consumes all its gas
Minimum cost500 gas
Complexity16 when the longer of base and modulus is at most 32 bytes; 2 × words² above that
Exponent lengthEach exponent byte past the first 32 counts 16 in the iteration count
DivisionNone: the cost is complexity × iteration count, not divided by 3

Unregistered precompile addresses​

These Ethereum precompiles are not registered:

AddressEthereum precompile
0x06, 0x07, 0x08BN254 add, scalar multiplication, pairing
0x09BLAKE2F
0x0aKZG point evaluation
0x0b–0x11BLS12-381 operations
0x100P256VERIFY (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.