Building MultiVM dApp

Details are provisional and may be updated during development.

Choosing the Optimal VM for Each Component

The key to maximizing performance on Arichain is understanding the strengths of each virtual machine and routing workloads accordingly.

Use EVM for:

• Complex state management and data structures

• Integration with existing DeFi protocols and libraries

• Governance and compliance requirements

• Rich smart contract interactions

• Mature tooling and debugging capabilities

Use SVM for:

• High-frequency operations (>1000 TPS requirements)

• Real-time gaming and interactive applications

• Simple but frequent transactions (payments, transfers)

• Parallel processing requirements

• Predictable cost structures

Performance Optimization Patterns

// Pattern 1: Route by Operation Type
class OptimizedTradingDApp {
    constructor() {
        this.evmProvider = new ethers.JsonRpcProvider(EVM_RPC);
        this.svmConnection = new Connection(SVM_RPC);
        this.arichain = new ArichainClient({ evmRpc: EVM_RPC, svmRpc: SVM_RPC });
    }
    
    async executeTrade(tradeParams) {
        // Route based on trade characteristics
        if (tradeParams.isHighFrequency && tradeParams.isSimple) {
            // Use SVM for high-frequency simple trades
            return this.executeOnSVM(tradeParams);
        } else if (tradeParams.requiresComplexLogic) {
            // Use EVM for complex DeFi integrations
            return this.executeOnEVM(tradeParams);
        } else {
            // Use unified approach for hybrid trades
            return this.executeHybridTrade(tradeParams);
        }
    }
    
    async executeHybridTrade(params) {
        // Step 1: Complex calculation on EVM
        const calculation = await this.evmContract.calculateOptimalRoute(params);
        
        // Step 2: High-speed execution on SVM
        const execution = await this.svmProgram.methods
            .executeCalculatedTrade(calculation)
            .rpc();
        
        // Step 3: Unified result tracking
        return this.arichain.trackTradeResult(calculation.id, execution);
    }
}

// Pattern 2: Batch Operations for Efficiency
class BatchOptimizedDApp {
    async processBatchOperations(operations) {
        // Group operations by VM for optimal batching
        const evmOps = operations.filter(op => op.complexity === 'high');
        const svmOps = operations.filter(op => op.frequency === 'high');
        
        // Execute batches in parallel
        const [evmResults, svmResults] = await Promise.all([
            this.executeBatchOnEVM(evmOps),
            this.executeBatchOnSVM(svmOps)
        ]);
        
        // Combine results with unified interface
        return this.arichain.combineResults(evmResults, svmResults);
    }
}

Gas Optimization Strategies

// EVM Gas Optimization (same as Ethereum)
contract GasOptimizedContract {
    // Use packed structs for storage efficiency
    struct PackedData {
        uint128 value1;
        uint128 value2;
        bool flag;
    }
    
    // Batch operations to reduce transaction costs
    function batchUpdate(uint256[] calldata ids, uint256[] calldata values) external {
        require(ids.length == values.length, "Length mismatch");
        
        for (uint256 i = 0; i < ids.length; i++) {
            // Update multiple values in single transaction
            _updateValue(ids[i], values[i]);
        }
    }
}

// SVM Compute Optimization (same as Solana)
#[program]
pub mod compute_optimized {
    pub fn batch_process(
        ctx: Context<BatchProcess>,
        operations: Vec<Operation>
    ) -> Result<()> {
        // Process multiple operations in single transaction
        // to minimize compute unit usage
        for operation in operations.iter() {
            process_single_operation(ctx.accounts, operation)?;
        }
        Ok(())
    }
}

Real-World Examples

Example 1: Hybrid Gaming Platform

A gaming platform that maximizes performance by using SVM for real-time gameplay and EVM for complex economic systems.

// SVM: Real-time game logic (high performance required)
#[program]
pub mod realtime_game {
    pub fn process_player_action(
        ctx: Context<ProcessAction>,
        action: PlayerAction,
        timestamp: i64
    ) -> Result<()> {
        let game_state = &mut ctx.accounts.game_state;
        
        // Process action with sub-second latency
        match action {
            PlayerAction::Move { x, y } => {
                // Update position instantly
                game_state.player_position = Position { x, y };
                game_state.last_action_time = timestamp;
            },
            PlayerAction::Attack { target_id } => {
                // Process attack with parallel execution
                process_attack(game_state, target_id, timestamp)?;
            }
        }
        
        // Emit real-time event
        emit!(PlayerActionProcessed {
            player_id: ctx.accounts.player.key(),
            action,
            timestamp
        });
        
        Ok(())
    }
}

// EVM: Complex economic system (rich libraries needed)
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract GameEconomy is ERC20, Ownable {
    using SafeMath for uint256;
    
    struct PlayerEconomics {
        uint256 totalEarnings;
        uint256 investmentLevel;
        uint256 lastRewardTime;
        mapping(address => uint256) tokenBalances;
    }
    
    mapping(address => PlayerEconomics) public playerEconomics;
    
    function calculateComplexReward(
        address player,
        uint256 gameScore,
        uint256 timePlayed
    ) external returns (uint256 reward) {
        PlayerEconomics storage playerEcon = playerEconomics[player];
        
        // Complex reward calculation using battle-tested libraries
        uint256 baseReward = gameScore.mul(REWARD_MULTIPLIER);
        uint256 timeBonus = calculateTimeBonus(timePlayed);
        uint256 investmentBonus = calculateInvestmentBonus(playerEcon.investmentLevel);
        
        reward = baseReward.add(timeBonus).add(investmentBonus);
        
        // Update player economics
        playerEcon.totalEarnings = playerEcon.totalEarnings.add(reward);
        playerEcon.lastRewardTime = block.timestamp;
        
        // Mint reward tokens
        _mint(player, reward);
        
        emit RewardCalculated(player, gameScore, reward);
    }
}

// Client: Unified gaming experience
class HybridGameClient {
    constructor() {
        // SVM for real-time operations
        this.svmConnection = new Connection('https://svm-rpc.arichain.network (TBD)');
        this.gameProgram = new Program(gameIdl, gameProgramId, { 
            connection: this.svmConnection 
        });
        
        // EVM for economic operations
        this.evmProvider = new ethers.JsonRpcProvider('https://evm-rpc.arichain.network (TBD)');
        this.economyContract = new ethers.Contract(economyAddress, economyAbi, this.evmProvider);
        
        // Unified data layer
        this.arichain = new ArichainClient({
            evmRpc: 'https://evm-rpc.arichain.network (TBD)',
            svmRpc: 'https://svm-rpc.arichain.network (TBD)'
        });
    }
    
    async processGameSession(playerId, gameActions) {
        const startTime = Date.now();
        
        // Real-time game processing on SVM
        const gameResults = [];
        for (const action of gameActions) {
            const result = await this.gameProgram.methods
                .processPlayerAction(action, Date.now())
                .accounts({
                    player: playerId,
                    gameState: gameStateAccount
                })
                .rpc();
                
            gameResults.push(result);
        }
        
        const endTime = Date.now();
        const totalScore = gameResults.reduce((sum, result) => sum + result.score, 0);
        
        // Complex reward calculation on EVM
        const rewardTx = await this.economyContract.calculateComplexReward(
            playerId,
            totalScore,
            endTime - startTime
        );
        
        // Unified result tracking
        const sessionResult = await this.arichain.trackGameSession({
            playerId,
            gameResults,
            economicResult: rewardTx,
            totalScore,
            duration: endTime - startTime
        });
        
        return sessionResult;
    }
    
    async getPlayerStatus(playerId) {
        // Get unified player data across both VMs
        const [gameStats, economicStats] = await Promise.all([
            this.gameProgram.account.playerStats.fetch(playerId),
            this.economyContract.playerEconomics(playerId)
        ]);
        
        return {
            ...gameStats,
            ...economicStats,
            totalAssets: await this.arichain.getUnifiedAssets(playerId)
        };
    }
}

Example 2: High-Performance DeFi with Real-Time Components

A DeFi protocol that uses EVM for complex financial logic and SVM for high-frequency trading operations.

// EVM: Complex DeFi protocol logic
contract LiquidityProtocol {
    using SafeMath for uint256;
    
    function calculateOptimalLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountA,
        uint256 amountB,
        uint256 slippage
    ) external view returns (
        uint256 optimalAmountA,
        uint256 optimalAmountB,
        uint256 expectedLiquidity
    ) {
        // Complex calculations using battle-tested DeFi libraries
        IUniswapV2Pair pair = IUniswapV2Pair(factory.getPair(tokenA, tokenB));
        (uint256 reserveA, uint256 reserveB,) = pair.getReserves();
        
        // Sophisticated optimization algorithms
        (optimalAmountA, optimalAmountB) = calculateOptimalAmounts(
            amountA, amountB, reserveA, reserveB, slippage
        );
        
        expectedLiquidity = calculateExpectedLiquidity(
            optimalAmountA, optimalAmountB, pair.totalSupply()
        );
    }
}

// SVM: High-frequency trading execution
#[program]
pub mod hft_execution {
    pub fn execute_optimal_trade(
        ctx: Context<ExecuteTrade>,
        trade_params: OptimalTradeParams
    ) -> Result<()> {
        let trading_state = &mut ctx.accounts.trading_state;
        
        // High-frequency execution with parallel processing
        for trade in trade_params.trades.iter() {
            // Execute trades with minimal latency
            execute_single_trade(
                ctx.accounts,
                trade,
                &mut trading_state.liquidity_pool
            )?;
        }
        
        // Update state atomically
        trading_state.last_execution_time = Clock::get()?.unix_timestamp;
        trading_state.total_volume = trading_state.total_volume
            .checked_add(trade_params.total_volume)
            .unwrap();
        
        Ok(())
    }
}

App Examples

Starter Templates

We provide comprehensive starter templates that demonstrate best practices for MultiVM development.

# EVM Starter Template
npx create-arichain-app my-defi-app --template evm-defi
cd my-defi-app
npm install
npm run deploy:arichain

# SVM Starter Template  
npx create-arichain-app my-game-app --template svm-game
cd my-game-app
anchor build
anchor deploy --provider.cluster arichain

# Hybrid Template
npx create-arichain-app my-hybrid-app --template multivm-hybrid
cd my-hybrid-app
npm run setup:multivm
npm run deploy:both

Complete Example Applications

1. MultiVM DEX Template

• EVM contracts for complex AMM logic

• SVM programs for high-frequency order matching

• Unified frontend with cross-VM asset management

2. GameFi Platform Template

• SVM programs for real-time gameplay

• EVM contracts for NFT marketplace and governance

• Cross-VM asset transfers and unified wallet integration

3. Payment Processing Template

• SVM programs for high-throughput payments

• EVM contracts for complex settlement logic

• Real-time transaction monitoring across both VMs