LI.FI Adapter - Go SDK

🚀 Features

📦 Installation

Prerequisites

Install the SDK

go get github.com/morpheum-labs/lifi-adapter

Development Setup

# Clone the repository
git clone https://github.com/morpheum-labs/lifi-adapter.git
cd lifi-adapter
# Install dependencies
make deps
# Setup development environment
make dev-setup
# Run tests
make test

🚀 Quick Start

Basic Usage

package main
import (
 "context"
 "fmt"
 "log"
 
 "github.com/morpheum-labs/lifi-adapter/core"
)
func main() {
 // Create configuration
 config := core.NewConfig("your-app-name")
 config.SetAPIKey("your-api-key") // Optional for higher rate limits
 
 // Create client
 client := core.NewClient(config)
 
 // Get a quote
 quoteReq := core.QuoteRequest{
 FromAddress: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
 FromChain: core.ChainIDArbitrum,
 ToChain: core.ChainIDOptimism,
 FromToken: "0x0000000000000000000000000000000000000000", // ETH
 ToToken: "0x0000000000000000000000000000000000000000", // ETH
 FromAmount: "1000000000000000000", // 1 ETH in wei
 Slippage: 0.005, // 0.5%
 Order: core.OrderCheapest,
 }
 
 ctx := context.Background()
 quote, err := client.GetQuote(ctx, quoteReq)
 if err != nil {
 log.Fatal(err)
 }
 
 fmt.Printf("Quote: %+v\n", quote)
}

Using Services Architecture

package main
import (
 "context"
 "fmt"
 "log"
 
 "github.com/morpheum-labs/lifi-adapter/services"
 "github.com/morpheum-labs/lifi-adapter/util"
)
func main() {
 // Create configuration
 config := util.NewConfig("your-app-name")
 config.SetAPIKey("your-api-key")
 
 // Create services client
 servicesClient := services.NewServicesClient(config)
 
 // Get quote using services
 quoteReq := services.QuoteRequest{
 FromAddress: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
 FromChain: util.ChainIDArbitrum,
 ToChain: util.ChainIDOptimism,
 FromToken: "0x0000000000000000000000000000000000000000",
 ToToken: "0x0000000000000000000000000000000000000000",
 FromAmount: "1000000000000000000",
 Slippage: 0.005,
 Order: services.OrderCheapest,
 }
 
 ctx := context.Background()
 quote, err := servicesClient.GetQuote(ctx, quoteReq)
 if err != nil {
 log.Fatal(err)
 }
 
 fmt.Printf("Quote: %+v\n", quote)
}

Configuration

Basic Configuration

config := lifi.NewConfig("your-app-name")

With API Key

config := lifi.NewConfig("your-app-name")
config.SetAPIKey("your-lifi-api-key")

Custom RPC Endpoints

config := lifi.NewConfig("your-app-name")
config.SetRPC(lifi.ChainIDEthereum, "https://mainnet.infura.io/v3/your-project-id")
config.SetRPC(lifi.ChainIDArbitrum, "https://arb1.arbitrum.io/rpc")

API Methods

Get Quote

quote, err := client.GetQuote(ctx, lifi.QuoteRequest{
 FromChain: lifi.ChainIDArbitrum,
 ToChain: lifi.ChainIDOptimism,
 FromToken: "0x0000000000000000000000000000000000000000",
 ToToken: "0x0000000000000000000000000000000000000000",
 FromAmount: "1000000000000000000",
 Slippage: 0.005,
 Order: "CHEAPEST",
})

Get Routes

routes, err := client.GetRoutes(ctx, quoteReq)

Get Supported Tokens

tokens, err := client.GetTokens(ctx, lifi.ChainIDEthereum)

Get Supported Chains

chains, err := client.GetChains(ctx)

Get Available Tools

tools, err := client.GetTools(ctx)

Transaction Execution

Execute Quote

// Create executor
executor := lifi.NewExecutor(client)
// Execute quote
result, err := executor.ExecuteQuote(ctx, quote, privateKey)

Execute Route

// Execute complete route
results, err := executor.ExecuteRoute(ctx, route, privateKey)

Wait for Confirmation

// Wait for transaction confirmation
result, err := executor.WaitForConfirmation(ctx, txHash, chainID)

Supported Chains

EVM Chains

Non-EVM Chains

Building and Testing

Prerequisites

Build

make build

Run Tests

make test

Run Demo

make demo

Run with API Key

LIFI_API_KEY=your-api-key make demo

Run Integration Tests

LIFI_API_KEY=your-api-key make integration-test

Makefile Targets

Environment Variables

Examples

Basic Quote

package main
import (
 "context"
 "fmt"
 "log"
 
 "github.com/morpheum-labs/lifi-adapter"
)
func main() {
 config := lifi.NewConfig("my-app")
 client := lifi.NewClient(config)
 
 quoteReq := lifi.QuoteRequest{
 FromChain: lifi.ChainIDArbitrum,
 ToChain: lifi.ChainIDOptimism,
 FromToken: "0x0000000000000000000000000000000000000000",
 ToToken: "0x0000000000000000000000000000000000000000",
 FromAmount: "1000000000000000000",
 Slippage: 0.005,
 }
 
 quote, err := client.GetQuote(context.Background(), quoteReq)
 if err != nil {
 log.Fatal(err)
 }
 
 fmt.Printf("Quote: %+v\n", quote)
}

Multiple Routes

routes, err := client.GetRoutes(ctx, quoteReq)
if err != nil {
 log.Fatal(err)
}
for i, route := range routes {
 fmt.Printf("Route %d: %s -> %s (%d steps)\n", 
 i+1, route.FromAmount, route.ToAmount, len(route.Steps))
}

Transaction Execution

// Parse private key
privateKeyBytes, err := hex.DecodeString("your-private-key-hex")
if err != nil {
 log.Fatal(err)
}
privateKey, err := crypto.ToECDSA(privateKeyBytes)
if err != nil {
 log.Fatal(err)
}
// Create executor
executor := lifi.NewExecutor(client)
// Execute quote
result, err := executor.ExecuteQuote(ctx, quote, privateKey)
if err != nil {
 log.Fatal(err)
}
fmt.Printf("Transaction Hash: %s\n", result.TransactionHash)

🛡️ Error Handling

Basic Error Handling

quote, err := client.GetQuote(ctx, req)
if err != nil {
 // Handle API errors, network errors, etc.
 log.Printf("Error getting quote: %v", err)
 return
}

Structured Error Types

import "github.com/morpheum-labs/lifi-adapter/errors"
// Check error types
if lifiErr, ok := err.(*errors.LiFiError); ok {
 switch lifiErr.Code {
 case errors.ErrorCodeNoRouteFound:
 log.Printf("No route found: %s", lifiErr.Message)
 case errors.ErrorCodeQuoteExpired:
 log.Printf("Quote expired: %s", lifiErr.Message)
 case errors.ErrorCodeSlippageExceeded:
 log.Printf("Slippage exceeded: %s", lifiErr.Message)
 default:
 log.Printf("Error: %s (Code: %s, Severity: %s)", 
 lifiErr.Message, lifiErr.Code, lifiErr.Severity)
 }
}

Error Context and Analysis

// Create error with context
err := errors.NewLiFiErrorWithContext(
 errors.ErrorCodeInvalidInput,
 "Invalid amount provided",
 map[string]interface{}{
 "field": "amount",
 "value": "invalid",
 "chain": "ethereum",
 },
)
// Check if error is retryable
if err.IsRetryable() {
 // Implement retry logic
 time.Sleep(time.Second)
 // Retry operation
}
// Get error severity
if err.GetSeverity() == errors.SeverityCritical {
 // Handle critical error
 alerting.SendAlert(err)
}

Error Collection and Analysis

// Create error collection
collection := errors.NewErrorCollection()
// Add errors
collection.AddError(err1)
collection.AddError(err2)
// Analyze errors
analyzer := errors.NewErrorAnalyzer(collection.GetErrors())
analysis := analyzer.Analyze()
// Get error statistics
fmt.Printf("Total errors: %d\n", analysis.GetTotalErrors())
fmt.Printf("Critical rate: %.2f%%\n", analysis.GetCriticalErrorRate())
fmt.Printf("Most common error: %s\n", analysis.GetMostCommonError())

Error Formatting

// Default formatting
fmt.Println(errors.FormatError(err))
// JSON formatting for APIs
jsonFormatter := errors.GetJSONFormatter()
jsonOutput := jsonFormatter.Format(err)
// Detailed formatting for logs
detailedFormatter := errors.GetDetailedFormatter()
logOutput := detailedFormatter.Format(err)

Error Types by Category

Chain Errors

Token Errors

Transaction Errors

Quote Errors

🏗️ Architecture

Core Components

lifi-adapter/
├── core/ # Core client and types
├── services/ # Service layer (quotes, execution, etc.)
├── errors/ # Comprehensive error handling
├── util/ # Utilities and validation
├── types/ # Shared type definitions
└── core/
 ├── evm/ # EVM chain implementations
 ├── sui/ # Sui chain implementation
 ├── svm/ # Solana implementation
 └── utxo/ # UTXO chains (Bitcoin, Litecoin, Dogecoin)

Services Architecture

// Services provide modular functionality
servicesClient := services.NewServicesClient(config)
// Quote service
quote, err := servicesClient.GetQuote(ctx, quoteReq)
// Execution service
result, err := servicesClient.ExecuteQuote(ctx, quote, privateKey)
// Status service
status, err := servicesClient.GetStatus(ctx, txHash, chainID)
// Chains service
chains, err := servicesClient.GetChains(ctx)
// Tokens service
tokens, err := servicesClient.GetTokens(ctx, chainID)
// Tools service
tools, err := servicesClient.GetTools(ctx)

Chain-Specific Implementations

EVM Chains

// Ethereum, Arbitrum, Optimism, Polygon, BSC, etc.
evmClient, err := core.NewEVMClientFromConfig(chainID, config)

Sui Chain

// Sui blockchain support
suiClient, err := core.NewSuiClient(config)

Solana (SVM)

// Solana support
svmClient, err := core.NewSVMClient(config)

UTXO Chains

// Bitcoin, Litecoin, Dogecoin
bitcoinClient := utxo.NewBitcoinClient(config)
litecoinClient := utxo.NewLitecoinClient(config)
dogecoinClient := utxo.NewDogecoinClient(config)

📊 Rate Limits

🛠️ Development

Development Workflow

# Setup development environment
make dev-setup
# Install dependencies
make deps
# Run tests
make test
# Run tests with coverage
make test-coverage
# Run linting
make lint
# Format code
make format
# Run security scan
make security
# Build for all platforms
make build-all

Testing

# Run all tests
make test
# Run tests with coverage
make test-coverage
# Run integration tests (requires API key)
LIFI_API_KEY=your-key make integration-test
# Run race detection
make race
# Run benchmarks
make bench

Code Quality

# Lint code
make lint
# Format code
make format
# Security scan
make security
# Update dependencies
make update-deps

Building

# Build for current platform
make build
# Build for specific platforms
make build-linux
make build-windows
make build-darwin
# Build for all platforms
make build-all

🤝 Contributing

Development Guidelines

Code Style

License

Support

📝 Changelog

v1.1.0 (Latest)

v1.0.0

🔮 Roadmap