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:bothComplete 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
Last updated