Skip to main content

EVM Compatibility

Ethereum Virtual Machine Integration​

Orbinum Network achieves full Ethereum Virtual Machine (EVM) compatibility through Substrate's Frontier pallet, enabling developers to deploy existing Solidity smart contracts and interact with the network using standard Ethereum tooling. This compatibility layer provides seamless integration with the broader Ethereum ecosystem while maintaining the performance and flexibility advantages of Substrate's native runtime.

Why EVM on Orbinum? Beyond standard smart contract deployment, EVM compatibility enables multichain AI agents to leverage smart contracts for complex coordination logic, autonomous decision-making, and interaction with Orbinum's unique features like AI inference through Orbits, cross-chain execution, and optional privacy capabilities. Developers can build sophisticated agent behaviors using familiar Solidity patterns while accessing Orbinum's native AI and multichain infrastructure through custom precompiled contracts.

Smart Contract Deployment​

Solidity Compatibility​

Orbinum supports Solidity smart contracts compiled to EVM bytecode, with full compatibility for:

  • Solidity versions 0.5.x through 0.8.x
  • All standard EVM opcodes
  • Ethereum precompiled contracts (ecrecover, sha256, ripemd160, identity, modexp, etc.)
  • EIP-1559 transaction format
  • EIP-2930 access lists
  • Contract creation and interaction
  • Event emission and logging

Deployment Process​

Smart contracts can be deployed using standard Ethereum development tools:

Using Hardhat:

// hardhat.config.js
module.exports = {
  networks: {
    orbinum: {
      url: "https://rpc.orbinum.network", // TBD - Subject to change
      chainId: 1234, // TBD - Orbinum chain ID (subject to change)
      accounts: [privateKey]
    }
  },
  solidity: "0.8.19"

### Gas Mechanics

EVM gas mechanics on Orbinum follow Ethereum standards with some platform-specific considerations:

**Gas Refunds**: Partial gas refunds are provided for storage deletion and contract self-destruction, following Ethereum's gas refund rules.
**Development Frameworks**: Hardhat, Truffle, Foundry, and Remix IDE work without modification
→ [Learn more about Wallets & Account Management](./wallets.mdx)
Developers can use familiar libraries like **ethers.js**, **web3.js**, **viem**, and **web3.py** without modification, simply by pointing them to Orbinum's RPC endpoint.
### Block Time and Finality
### Account Model

**Native Accounts**: Substrate-native accounts use different cryptographic schemes (ED25519/SR25519) compared to Ethereum's SECP256k1.
**Native Token**: Gas is paid in $ON tokens rather than ETH, with automatic conversion handled by the platform.

**Universal Gas Abstraction**: For cross-chain operations, Orbinum's universal gas system abstracts destination chain gas requirements.

### Precompiled Contracts

In addition to standard Ethereum precompiles (ecrecover, sha256, ripemd160, identity, modexp, etc.), Orbinum provides **custom precompiled contracts** that expose native platform features to EVM smart contracts:

#### Orbit AI Inference Precompile

Request AI inference from Orbits directly from Solidity contracts:

```solidity
// Interface for Orbit AI Inference (address: 0x0000000000000000000000000000000000000800)
interface IOrbitInference {
    /// @notice Request AI inference from a specific Orbit
    /// @param orbitId The ID of the target Orbit
    /// @param prompt The inference prompt/input
    /// @return requestId Unique identifier for tracking the request
    function requestInference(
        uint256 orbitId,
        string calldata prompt
    ) external payable returns (bytes32 requestId);
    
    /// @notice Retrieve inference result
    /// @param requestId The request identifier
    /// @return result The AI inference result
    /// @return isReady Whether the result is ready
    function getResult(bytes32 requestId) 
        external view returns (string memory result, bool isReady);
}

Example Usage:

contract AITradingStrategy {
    IOrbitInference constant ORBIT = IOrbitInference(0x0000000000000000000000000000000000000800);
    
    function analyzeMarket(string memory marketData) external payable {
        bytes32 requestId = ORBIT.requestInference{value: msg.value}(
            1, // NLP Orbit ID
            marketData
        );
        // Store requestId for later retrieval
    }
}

Cross-Chain Messaging Precompile​

Execute transactions on external blockchains:

// Interface for Cross-Chain Execution (address: 0x0000000000000000000000000000000000000801)
interface ICrossChain {
    /// @notice Execute a transaction on a target chain
    /// @param targetChain Chain identifier (1=Ethereum, 2=Solana, etc.)
    /// @param targetAddress Destination address on target chain
    /// @param callData Transaction payload
    /// @return messageId Cross-chain message identifier
    function executeOnChain(
        uint256 targetChain,
        bytes calldata targetAddress,
        bytes calldata callData
    ) external payable returns (bytes32 messageId);
    
    /// @notice Check execution status
    /// @param messageId The message identifier
    /// @return executed Whether execution completed
    /// @return success Whether execution succeeded
    function getExecutionStatus(bytes32 messageId) 
        external view returns (bool executed, bool success);
}

Quality Ranking Precompile​

Query miner and validator quality scores:

// Interface for Quality Queries (address: 0x0000000000000000000000000000000000000802)
interface IQualityRanking {
    /// @notice Get quality score for a miner
    /// @param minerId The miner's account ID
    /// @param orbitId The Orbit ID
    /// @return score Quality score (0-100)
    function getMinerScore(bytes32 minerId, uint256 orbitId) 
        external view returns (uint256 score);
    
    /// @notice Get top miners for an Orbit
    /// @param orbitId The Orbit ID
    /// @param limit Maximum number of results
    /// @return minerIds Array of top miner IDs
    function getTopMiners(uint256 orbitId, uint256 limit) 
        external view returns (bytes32[] memory minerIds);
}

Governance Precompile​

Interact with on-chain governance:

// Interface for Governance (address: 0x0000000000000000000000000000000000000803)
interface IGovernance {
    /// @notice Submit a governance proposal
    /// @param proposalHash Hash of the proposal
    /// @param deposit Proposal deposit amount
    /// @return proposalId The created proposal ID
    function submitProposal(bytes32 proposalHash, uint256 deposit) 
        external returns (uint256 proposalId);
    
    /// @notice Vote on a proposal
    /// @param proposalId The proposal to vote on
    /// @param approve True to approve, false to reject
    /// @param conviction Conviction multiplier (0-6)
    function vote(uint256 proposalId, bool approve, uint8 conviction) external;
}

EVM Use Cases on Orbinum​

Orbinum's EVM compatibility combined with native AI and multichain capabilities enables unique use cases:

AI-Powered DeFi​

Smart contracts that leverage Orbit AI for autonomous decision-making:

  • Intelligent Yield Optimization: Contracts that analyze market conditions via NLP Orbit and rebalance portfolios automatically
  • Sentiment-Based Trading: Trading strategies that incorporate social media sentiment analysis from AI miners
  • Risk Assessment: Lending protocols that use AI to evaluate borrower risk profiles
  • Predictive Market Making: AMMs that adjust parameters based on AI-predicted volatility

Example:

contract IntelligentVault {
    IOrbitInference orbit = IOrbitInference(0x0000000000000000000000000000000000000800);
    
    function rebalance() external {
        // Request market analysis from NLP Orbit
        bytes32 reqId = orbit.requestInference{value: 0.1 ether}(
            1, 
            "Analyze current DeFi market conditions and recommend portfolio allocation"
        );
        // Process result and execute rebalancing
    }
}

Multichain Agent Coordination​

Contracts that orchestrate complex cross-chain workflows:

  • Cross-Chain Arbitrage: Detect and execute arbitrage opportunities across multiple DEXs on different chains
  • Multichain Treasury Management: Manage assets across Ethereum, Solana, Polygon from a single contract
  • Universal Liquidity Provision: Provide liquidity to pools on multiple chains with unified management
  • Cross-Chain Governance: Coordinate DAO votes and execution across multiple networks

Example:

contract MultiChainArbitrage {
    ICrossChain crossChain = ICrossChain(0x0000000000000000000000000000000000000801);
    
    function executeArbitrage(
        bytes calldata ethSwapData,
        bytes calldata polySwapData
    ) external payable {
        // Execute swap on Ethereum
        crossChain.executeOnChain{value: msg.value / 2}(
            1, // Ethereum
            abi.encode(uniswapRouter),
            ethSwapData
        );
        
        // Execute swap on Polygon
        crossChain.executeOnChain{value: msg.value / 2}(
            3, // Polygon
            abi.encode(quickswapRouter),
            polySwapData
        );
    }
}

Autonomous Agent Logic​

Smart contracts that serve as the "brain" for multichain AI agents:

  • Agent State Management: Store agent memory, preferences, and learned behaviors on-chain
  • Decision Trees: Implement complex decision logic that combines AI inference with on-chain data
  • Multi-Step Workflows: Coordinate sequences of AI inference and cross-chain actions
  • Agent Governance: Enable agents to participate in DAO governance based on AI analysis

Quality-Aware Applications​

Contracts that leverage Orbinum's quality ranking system:

  • Miner Selection: Choose high-quality miners for critical AI inference tasks
  • Performance Bonding: Require minimum quality scores for service providers
  • Reputation Systems: Build applications that reward consistent high-quality performance
  • Dynamic Pricing: Adjust fees based on provider quality scores

Example:

contract QualityAwareService {
    IQualityRanking quality = IQualityRanking(0x0000000000000000000000000000000000000802);
    
    function requestPremiumInference(string memory prompt) external payable {
        // Get top 3 miners for Vision Orbit
        bytes32[] memory topMiners = quality.getTopMiners(2, 3);
        
        // Request inference from highest-quality miner
        // Implementation details...
    }
}

Differences from Ethereum​

While Orbinum maintains high EVM compatibility, key differences include:

Block Time & Finality: 6-second blocks with deterministic finality in 12-18 seconds (vs. Ethereum's probabilistic finality)

Gas Token: Transactions paid in $ON instead of ETH

Custom Precompiles: Native access to AI inference, cross-chain execution, quality ranking, and governance

Universal Gas Abstraction: Pay for multichain operations in $ON without managing multiple gas tokens

→ Learn more about System Architecture

Best Practices​

Contract Development: Test thoroughly on testnet before mainnet deployment. Implement upgradable patterns for flexibility.

Security: Use reentrancy guards, access control patterns, and conduct professional audits for high-value contracts.

AI Inference Integration: Handle asynchronous results with callback patterns or polling. Budget gas appropriately for result retrieval.

Precompiled Contracts: Leverage Orbinum's custom precompiles for AI inference, cross-chain execution, and quality ranking.

→ Learn more about Wallets & Account Management

Migration from Ethereum​

Contract Migration​

Existing Ethereum contracts can be migrated to Orbinum with minimal modifications:

  1. Compile Contracts: Ensure contracts compile with Solidity 0.8.x or compatible version
  2. Update Network Configuration: Configure deployment tools to target Orbinum RPC endpoint
  3. Test Thoroughly: Deploy to testnet and verify all functionality works as expected
  4. Update Frontend: Modify dApp frontend to connect to Orbinum network
  5. Deploy to Mainnet: Deploy contracts to Orbinum mainnet after successful testing

State Migration​

For contracts requiring state migration from Ethereum:

  1. Export State: Extract contract state from Ethereum using archive node
  2. Initialize Contract: Deploy contract to Orbinum with initialization function
  3. Import State: Populate contract state through initialization or migration transactions
  4. Verify Consistency: Confirm migrated state matches original Ethereum state

Resources​

Network Endpoints​

Note: Network endpoints and Chain IDs are subject to change before mainnet launch. Always verify current values in official documentation.

Documentation​

Development Resources​

  • GitHub: https://github.com/orbinum-network
  • Precompiled Contracts Reference: (Coming soon)
  • Example Contracts: (Coming soon)
  • Hardhat Plugin: (Coming soon)
  • Community Discord: (TBD)