> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getpara.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Solana Integration

> Sign Solana transactions using Para's unified wallet architecture

## Quick Start

```swift theme={null}
import ParaSwift

// Sign a Solana transaction
let paraManager = ParaManager(apiKey: "your-api-key")
// Get an existing Solana wallet or create one
let wallets = try await paraManager.fetchWallets()
let wallet: Wallet
if let existing = wallets.first(where: { $0.type == .solana }) {
    wallet = existing
} else {
    wallet = try await paraManager.createWallet(type: .solana, skipDistributable: false)
}

let transaction = try SolanaTransaction(
    to: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
    lamports: UInt64(1_000_000), // 0.001 SOL
    feePayer: nil, // Uses wallet as fee payer
    recentBlockhash: nil // Fetched automatically with RPC URL
)

let result = try await paraManager.signTransaction(
    walletId: wallet.id,
    transaction: transaction,
    chainId: nil, // Not needed for Solana
    rpcUrl: "https://api.devnet.solana.com"
)
print("Transaction signed: \(result.signedTransaction)")
```

## Common Operations

### Sign Transaction

```swift theme={null}
let transaction = try SolanaTransaction(
    to: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
    lamports: UInt64(1_000_000), // 0.001 SOL
    feePayer: nil, // Uses wallet as fee payer
    recentBlockhash: nil // Fetched automatically with RPC URL
)

let result = try await paraManager.signTransaction(
    walletId: wallet.id,
    transaction: transaction,
    chainId: nil, // Not needed for Solana
    rpcUrl: "https://api.devnet.solana.com"
)
print("Signed: \(result.signedTransaction)")
```

### Check Balance

```swift theme={null}
let balance = try await paraManager.getBalance(
    walletId: wallet.id,
    token: nil, // Native SOL
    rpcUrl: "https://api.devnet.solana.com"
)

// Convert lamports to SOL
let lamports = Double(balance) ?? 0
let sol = lamports / 1_000_000_000
print("Balance: \(String(format: "%.4f", sol)) SOL")
```

### Sign Message

```swift theme={null}
let message = "Hello, Solana!"
let result = try await paraManager.signMessage(
    walletId: wallet.id,
    message: message
)
print("Signature: \(result.signedTransaction)")
```

## Networks

### Testnets

| Network     | RPC URL                          | Native Token |
| ----------- | -------------------------------- | ------------ |
| **Devnet**  | `https://api.devnet.solana.com`  | SOL          |
| **Testnet** | `https://api.testnet.solana.com` | SOL          |

### Mainnets

| Network     | RPC URL                                            | Native Token | Network Type |
| ----------- | -------------------------------------------------- | ------------ | ------------ |
| **Mainnet** | `https://api.mainnet-beta.solana.com`              | SOL          | Production   |
| **Alchemy** | `https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY` | SOL          | Production   |

## Complete Example

```swift theme={null}
import SwiftUI
import ParaSwift

struct SolanaWalletView: View {
    @EnvironmentObject var paraManager: ParaManager
    @State private var isLoading = false
    @State private var signature: String?

    let wallet: Wallet
    private let rpcUrl = "https://api.devnet.solana.com"

    var body: some View {
        VStack(spacing: 20) {
            Text(wallet.address ?? "No address")
                .font(.system(.caption, design: .monospaced))

            Button(action: signTransaction) {
                Text(isLoading ? "Signing..." : "Sign Transaction")
            }
            .disabled(isLoading)

            if let signature = signature {
                Text("Signed: \(signature)")
                    .font(.caption)
            }
        }
        .padding()
    }

    private func signTransaction() {
        isLoading = true
        Task {
            do {
                let transaction = try SolanaTransaction(
                    to: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
                    lamports: 1_000_000, // 0.001 SOL
                    feePayer: nil,
                    recentBlockhash: nil
                )

                let result = try await paraManager.signTransaction(
                    walletId: wallet.id,
                    transaction: transaction,
                    chainId: nil, // Not needed for Solana
                    rpcUrl: rpcUrl
                )
                signature = result.signedTransaction
            } catch {
                print("Error: \(error)")
            }
            isLoading = false
        }
    }
}
```

## Advanced Transaction Options

```swift theme={null}
// Transaction with compute budget
let transaction = try SolanaTransaction(
    to: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
    lamports: UInt64(1_000_000),
    computeUnitLimit: UInt32(200_000), // Set compute budget
    computeUnitPrice: UInt64(1_000) // Set priority fee
)

// Transaction with custom blockhash
let transaction = try SolanaTransaction(
    to: "9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM",
    lamports: UInt64(1_000_000),
    recentBlockhash: "custom_blockhash",
    feePayer: wallet.address
)
```

## Pre-Serialized Transactions

Sign base64-encoded Solana transactions from dApps or backend services.

```swift theme={null}
let base64Transaction = "AQABA8GlkLb8bd/L6i5/YftGpxyig/iBvof2eNEF9WPF2o0Z..."

let result = try await paraManager.signSolanaSerializedTransaction(
    walletId: wallet.id,
    base64Tx: base64Transaction
)
```

### Use Cases

```swift theme={null}
// From dApp
let serializedTx = dApp.getSerializedTransaction()
let signature = try await paraManager.signSolanaSerializedTransaction(
    walletId: wallet.id,
    base64Tx: serializedTx
)

// From backend
let preparedTx = await backend.prepareTransaction()
let result = try await paraManager.signSolanaSerializedTransaction(
    walletId: wallet.id,
    base64Tx: preparedTx.serialized
)
```

Accepts base64-encoded bytes from `transaction.serializeMessage()` or compatible Solana SDKs.