Solana Service

Comprehensive transaction handling service for the Solana blockchain, featuring Jito bundles and priority fee mechanisms for optimized transaction processing.

Overview

The Solana service provides a unified interface for handling Solana blockchain transactions with support for:

• Priority Fee Transactions: Enhanced processing with configurable fee tiers
• Jito Bundle Transactions: MEV-protected transactions through Jito’s block engine
• Automated Commission System: Built-in 0.5% commission handling
• Mobile Wallet Adapter Support: Native mobile wallet integration

Transaction Processing

• Priority fee management (4 tiers)
• Jito bundle support
• SOL and Token transfers
• Mobile Wallet Adapter (MWA)
• Versioned transactions

Priority Fee System

• Low, Medium, High, Very-High tiers
• Dynamic calculation
• Compute unit optimization
• Real-time tier selection

Jito Integration

• MEV-protected transactions
• Bundle submission
• Status tracking
• Block engine communication

Error Handling

• Comprehensive error parsing
• Retry mechanisms
• Confirmation validation
• Status callbacks

Module Structure

src/shared/services/transactions/
├── index.ts                    # Main exports
├── methods/                    # Transaction execution methods
│   ├── sendSOL.ts             # SOL transfers
│   ├── sendToken.ts           # Token transfers
│   ├── priority.ts            # Priority fee transactions
│   └── jito.ts               # Jito bundle transactions
├── core/                      # Core utilities and configurations
│   ├── types.ts              # TypeScript interfaces
│   ├── constants.ts          # Configuration constants
│   ├── commission.ts         # Commission utilities
│   ├── helpers.ts            # Transaction helpers
│   └── errorParser.ts        # Error handling
└── README.md                  # Documentation

Priority Fee System

Fee Tiers

Tier	MicroLamports	Use Case
Low	1,000	Standard transactions
Medium	10,000	Normal priority
High	100,000	High priority
Very-High	1,000,000	Critical transactions

Configuration

export const DEFAULT_FEE_MAPPING: FeeMapping = {
  'low': 1_000,
  'medium': 10_000,
  'high': 100_000,
  'very-high': 1_000_000,
};

Auto Instructions

• Compute Unit Limit: 2,000,000 units
• Compute Unit Price: Based on selected tier
• Dynamic Selection: Retrieved from Redux state

Jito Bundle Integration

Show Benefits & Features

Feature	Description
Bundle Submission	Groups transactions for atomic execution
MEV Protection	Prevents front-running and sandwich attacks
Guaranteed Inclusion	Higher success rate for critical transactions
Status Tracking	Real-time bundle monitoring
Block Engine	Direct integration with Jito’s block engine

Show Configuration & Setup

// Jito Bundle Configuration
export const JITO_BUNDLE_URL = ENDPOINTS.jito?.blockEngine || '';

interface JitoBundleResponse {
  jsonrpc: string;
  result: string;
  id: number;
}

interface JitoBundleConfig {
  maxRetries: number;
  retryInterval: number;
  timeout: number;
}

Show Usage Guidelines

Scenario	Recommendation
High-Value Trades	Always use Jito bundles
Token Launches	Bundle multiple setup transactions
Arbitrage	Protect against frontrunning
Concurrent Txs	Group related transactions

Transaction Methods

Core Functions

sendSOL

// Sends SOL with optional commission and priority fees
const signature = await sendSOL({
  wallet: connectedWallet,
  recipientAddress: 'recipient_address',
  amountSol: 0.1,
  connection: solanaConnection,
  includeCommission: true,
  onStatusUpdate: (status) => console.log(status)
});

// Sends SPL tokens with automatic account creation
const signature = await sendToken({
  wallet: connectedWallet,
  recipientAddress: 'recipient_address',
  amount: tokenAmount,
  mint: tokenMint,
  connection: solanaConnection,
  includeCommission: true,
  onStatusUpdate: (status) => console.log(status)
});

// Executes transactions with configurable priority fees
const signature = await sendTransactionWithPriorityFee({
  wallet: connectedWallet,
  instructions: transactionInstructions,
  connection: solanaConnection,
  shouldUsePriorityFee: true,
  includeCommission: true,
  onStatusUpdate: (status) => console.log(status)
});

// Executes MEV-protected transactions
const signature = await sendJitoBundleTransaction({
  provider: walletProvider,
  instructions: transactionInstructions,
  walletPublicKey: userPublicKey,
  connection: solanaConnection,
  onStatusUpdate: (status) => console.log(status)
});

Commission System

The service includes an automated 0.5% commission system for all transactions.

// Commission calculation utilities
interface CommissionUtils {
  calculateCommissionLamports(transactionLamports: number): number;
  createCommissionInstruction(fromPubkey: PublicKey, transactionLamports: number): TransactionInstruction;
  calculateTransferAmountAfterCommission(totalLamports: number): {
    transferLamports: number;
    commissionLamports: number;
  };
}

Error Handling & Retries

export const TRANSACTION_RETRIES = {
  maxAttempts: 6,
  interval: 1500,
  confirmationAttempts: 3,
  confirmationInterval: 1000,
  blockhashAttempts: 3,
  blockhashInterval: 500,
};

Error types include:

• Confirmation failures
• Network issues
• Wallet errors
• Insufficient funds

Mobile Wallet Adapter Support

Android

// Android-specific transaction handling
if (Platform.OS === 'android') {
  const signature = await sendPriorityTransactionMWA(
    connection,
    recipientAddress,
    lamportsAmount,
    feeMapping,
    (status) => console.log(status)
  );
}

Configuration

Environment Variables

# Commission wallet address
COMMISSION_WALLET=your_commission_wallet_address

# Jito configuration
JITO_BUNDLE_URL=https://your-jito-endpoint

# Solana cluster
CLUSTER=mainnet-beta

Redux Integration

// Get current settings from Redux state
const transactionMode = getCurrentTransactionMode(); // 'jito' | 'priority'
const feeTier = getCurrentFeeTier(); // 'low' | 'medium' | 'high' | 'very-high'
const feeAmount = getCurrentFeeMicroLamports();

export type TransactionType = 'swap' | 'transfer' | 'stake' | 'nft' | 'token';
export type TransactionMode = 'jito' | 'priority';

Best Practices

Mode Selection

Use Jito for MEV-sensitive transactions, Priority fees for speed

Fee Tiers

Match tier to transaction urgency and importance

Error Handling

Implement comprehensive error handling with status callbacks

Platform Support

Check MWA compatibility for Android devices

---

For detailed API documentation and examples, see the API Reference section.