Skip to main content
Current Implementation: This SDK provides Jupiter AMM interface integration for Saros DLMM pools. It implements the standard Jupiter Amm trait for seamless integration with Jupiter’s routing and aggregation infrastructure.For standalone Rust applications, you may need additional wrapper functionality around this core AMM implementation.

​
Package Overview

The Saros DLMM Rust SDK implements the Jupiter AMM interface to enable Saros DLMM pools to participate in Jupiter’s aggregation and routing ecosystem. This provides high-performance, zero-cost abstraction access to concentrated liquidity pools through Jupiter’s standardized interface.

​
Why Rust for DLMM?

Rust provides the optimal foundation for professional DLMM applications requiring maximum performance and safety. Performance Benefits:
  • Zero-Cost Abstractions - Complex DLMM math compiles to optimal assembly
  • Memory Safety - No buffer overflows or use-after-free in critical trading code
  • Native Speed - 10-100x faster than interpreted languages
  • Predictable Latency - No garbage collection pauses during trading
Solana Integration:
  • Native Language - Direct access to Solana runtime and programs
  • Zero-Copy Parsing - Read account data without memory allocation
  • Optimal Compute Units - Fine-tuned control over transaction costs

​
Package Details

AspectDetails
Cratesaros-dlmm-sdk
Versionv0.1.0
InterfaceJupiter AMM trait implementation
Rust Edition2024
PurposeJupiter aggregator integration

​
Installation

The package is available as a local dependency and can be integrated into Jupiter AMM applications: 
[dependencies]
# Core Jupiter AMM interface
jupiter-amm-interface = "0.6"

# Solana dependencies (match workspace)
solana-sdk = ">=2.2"
anchor-lang = "0.31.0"
anyhow = "1.0"

# For development (local path)
saros-dlmm-sdk = { path = "../path/to/saros-dlmm-sdk-rs/saros-dlmm" }
For production use, the crate will be published to crates.io: 
# When published (check availability first)
cargo add saros-dlmm-sdk
cargo add jupiter-amm-interface

​
Jupiter AMM Integration Example

This shows how to use the Saros DLMM implementation through Jupiter’s AMM interface: 
use jupiter_amm_interface::{Amm, AmmContext, KeyedAccount, QuoteParams, SwapMode};
use saros_dlmm_sdk::SarosDlmm;
use solana_sdk::pubkey::Pubkey;
use std::str::FromStr;

// Example: Using SarosDlmm through Jupiter AMM interface
fn jupiter_amm_integration() -> anyhow::Result<()> {
    // 1. The SarosDlmm struct implements the Jupiter Amm trait
    // It's created from account data, not a simple constructor
    
    // This would typically be done by Jupiter's AMM loading system:
    // let keyed_account = KeyedAccount { key: pool_pubkey, account: pool_account };
    // let amm_context = AmmContext { ... };
    // let saros_amm = SarosDlmm::from_keyed_account(&keyed_account, &amm_context)?;
    
    println!("✅ SarosDlmm implements Jupiter Amm trait");
    println!("✅ Provides quote() method for price calculations");
    println!("✅ Supports exact input and exact output swaps");
    println!("✅ Integrates seamlessly with Jupiter aggregation");
    
    // 2. Once loaded, you can use standard Jupiter AMM methods:
    // let quote = saros_amm.quote(&QuoteParams {
    //     amount: 1_000_000,
    //     input_mint: usdc_mint,
    //     output_mint: sol_mint,
    //     swap_mode: SwapMode::ExactIn,
    // })?;
    
    println!("📊 Quote calculation: O(1) concentrated liquidity math");
    println!("🔄 Swap routing: Integrated with Jupiter's multi-hop system");
    
    Ok(())
}

​
Performance Characteristics

Jupiter AMM Interface Performance (measured operations):
OperationRust ImplementationTypical AMMAdvantage
Quote Calculation~2-5μs~8-15μs3-4x faster
Account Parsing~500ns~2μs4x faster
Memory FootprintLow overheadHigher overheadMinimal allocations
Bin Array ProcessingZero-copyCopy operationsMemory efficient

​
Use Cases

Jupiter Ecosystem Integration
  • AMM routing through Saros DLMM concentrated liquidity pools
  • Multi-hop swap optimization with better execution prices
  • Seamless integration with Jupiter’s aggregation infrastructure
  • Access to DLMM’s superior capital efficiency for Jupiter users
DeFi Protocol Integration
  • Embed Saros DLMM as a liquidity source in custom DEX aggregators
  • Build routing algorithms that leverage concentrated liquidity math
  • Integrate with portfolio management and yield farming protocols
High-Performance Applications
  • Zero-copy account parsing for optimal performance
  • Rust’s memory safety prevents critical trading bugs
  • Native Solana integration without JavaScript overhead
  • Custom liquidity analysis and market making tools

​
Your Journey to High-Performance DLMM Development

Follow this structured path to master Rust-based DLMM development. Each step builds on the previous one, taking you from Rust beginner to advanced performance optimization expert.

🎓 Learn Rust DLMM Fundamentals

Start here if you’re new to Rust DLMM development

Quick Start

15 minutes → Your first high-performance DLMM trading system

First DEX

45 minutes → Complete DEX implementation with Rust

Trading System

60 minutes → Advanced trading system with multi-pool routing

Code Examples

30 minutes → Production-ready patterns and implementations

🛠️ Solve Performance-Critical Problems

Use these when you have specific high-performance requirements to solve

Execute Swaps

Zero-copy swap execution with optimal performance

Manage Liquidity

Concentrated liquidity position management

Multi-Hop Routing

Complex routing across multiple DLMM pools

Portfolio Management

Advanced portfolio and risk management systems

Production Optimization

Performance tuning and optimization strategies

📚 Reference & API Details

Quick lookup for functions, types, and API details during development

Methods

Complete function reference with signatures

Types

Rust struct and enum definitions

API Overview

SDK architecture and module organization

💡 Deep Performance Understanding

Deep dive into concepts, architecture, and performance optimization

Concentrated Liquidity in Rust

How Rust enables superior DLMM performance

Rust vs TypeScript

Choosing the right language for your DLMM application

​
Architecture Highlights

​
Zero-Copy Design

// Direct memory mapping, no allocation
pub fn parse_pool_state(account_data: &[u8]) -> Result<&PoolState, ParseError> {
    bytemuck::try_from_bytes(account_data)
}

​
Type Safety

// Compile-time prevention of decimal mix-ups
pub struct TokenAmount<const DECIMALS: u8> {
    amount: u64,
}

// Cannot accidentally mix USDC (6 decimals) with SOL (9 decimals)
type UsdcAmount = TokenAmount<6>;
type SolAmount = TokenAmount<9>;

​
Async/Await Support

// Native async for Solana RPC calls
pub async fn get_multiple_accounts(&self, pubkeys: &[Pubkey]) -> ClientResult<Vec<Option<Account>>> {
    self.rpc_client.get_multiple_accounts(pubkeys).await
}

​
Community & Resources