# Altude – Full LLM Reference

> Gasless, non-custodial wallet infrastructure for Solana apps.

## Overview

Altude is a developer infrastructure platform purpose-built for the Solana blockchain. It solves the two biggest UX barriers in web3: wallets and gas. With Altude, developers ship consumer-grade Solana applications where users authenticate via passkeys or social login, never manage seed phrases, and never need to hold SOL to pay transaction fees.

Altude never holds or has access to user private keys. All key material stays on the user's device (via passkeys or device-secure storage). Altude sponsors gas by maintaining a fee-payer account on behalf of the app—users experience gasless transactions without the app developer having to build custom relayer infrastructure.

## Who It's For

### Primary Audience
- **Solana app developers** building token-gated apps, reward platforms, gaming economies, or DeFi tools.
- **Web2 product teams** entering web3 who need a clean REST API abstraction over Solana.
- **Game studios** integrating token economies into Unity, iOS, Android, or cross-platform Flutter titles.
- **Enterprise teams** needing auditable, compliant wallet infrastructure with a managed dashboard.

### Use Cases
- Consumer apps where users earn, hold, or spend SPL tokens without crypto knowledge.
- Mobile games that reward players with on-chain assets.
- Loyalty and rewards programs using Solana token rails.
- NFT marketplaces with embedded checkout wallets.
- DeFi front-ends that abstract transaction signing complexity.

## Core Products

### 1. Gasless Wallet Infrastructure

Altude operates a gas sponsorship layer on Solana. When a user initiates a transaction through an Altude-powered app, the fee-payer account registered to the application covers the SOL transaction fee. Users experience zero-gas transactions while the developer manages fee budgets via the Altude dashboard.

**Key properties:**
- No SOL required in user wallets to execute transactions.
- Fee-payer is app-controlled, not user-controlled.
- Configurable fee limits and thresholds in the dashboard.
- Supports all SPL token transfers and account operations.

### 2. Non-Custodial Embedded Wallets

Altude generates and stores wallet keys using device-native secure storage (Secure Enclave on iOS, Android Keystore) or passkey standards (WebAuthn). The user holds the private key; Altude holds nothing.

**Key properties:**
- True self-custody: Altude cannot access, freeze, or move user funds.
- Keys generated from BIP-39 mnemonics or deterministic paths.
- Passkey authentication replaces seed phrase management.
- Compatible with all standard Solana wallets for recovery.

### 3. REST API

Altude exposes a versioned REST API for all core operations. Requests are authenticated with a per-app API key passed as a bearer token or query parameter.

**Base URL:** `https://your-altude-endpoint`

**Authentication:** API key via `Authorization: Bearer <api-key>` header or `?api-key=` query parameter.

#### Core Endpoints

| Method | Endpoint                    | Description                                      |
|--------|-----------------------------|--------------------------------------------------|
| POST   | `/api/account`              | Create a new on-chain account for a keypair.     |
| DELETE | `/api/account`              | Close an existing (empty) on-chain account.      |
| GET    | `/api/account/balance`      | Get token balance for a public key.              |
| GET    | `/api/account/history`      | Get transaction history for a public key.        |
| GET    | `/api/account/token-accounts` | List token accounts for a public key.          |
| POST   | `/api/airdrop`              | Request devnet airdrop to a public key.          |
| POST   | `/api/transaction/make-transfer` | Execute a token transfer.                  |
| POST   | `/api/transaction/make-transfer-batch` | Execute a batch of token transfers.  |
| GET    | `/api/transaction`          | Get details for a transaction signature.         |
| GET    | `/api/app`                  | Get configuration for the current app index.     |
| GET    | `/api/app/health`           | Health check for the app endpoint.               |

#### Request / Response Format

All requests and responses use JSON. Transfer amounts are passed as strings to avoid floating-point precision issues. Public keys are base58-encoded Solana public keys.

**Example – Create Account:**
```json
POST /api/account
{
  "environment": "devnet",
  "index": 1,
  "mint": "MintPublicKeyBase58",
  "owner": "OwnerPublicKeyBase58",
  "commitment": "Finalized"
}
```

**Example – Make Transfer:**
```json
POST /api/transaction/make-transfer
{
  "environment": "devnet",
  "index": 1,
  "mint": "MintPublicKeyBase58",
  "owner": "SenderPublicKeyBase58",
  "destination": "RecipientPublicKeyBase58",
  "amount": "100",
  "commitment": "Confirmed"
}
```

### 4. Developer Dashboard

The Altude dashboard is the control plane for all applications registered on the platform.

**Capabilities:**
- Register applications and obtain an App Index.
- Monitor real-time transaction volume, user counts, and fee spend.
- Manage fee-payer account balances and thresholds.
- View and export transaction history.
- Configure app environments (devnet / mainnet).
- Manage team members and access control.

## SDKs

Altude provides first-party SDKs for all major platforms. All SDKs wrap the REST API and handle keypair management, transaction signing, and commitment polling.

### SDK Table

| Platform       | Language       | Package / Import                         | Install Command                               |
|----------------|----------------|------------------------------------------|-----------------------------------------------|
| Web / Node.js  | TypeScript/JS  | `@altude/gasstation`                     | `npm install @altude/gasstation`             |
| Backend        | Python         | `kinetic-sdk`                            | `pip install kinetic-sdk`                    |
| iOS            | Swift          | `KineticSwift` via Swift Package Manager | Xcode → Add Package → GitHub URL            |
| Android        | Kotlin         | `kinetic-sdk-android`                    | Gradle dependency                            |
| Cross-platform | Flutter / Dart | `kinetic_flutter_sdk`                    | `flutter pub add kinetic_flutter_sdk`        |
| Games          | Unity / C#     | Altude Unity SDK                         | Unity Package Manager                        |

### TypeScript SDK – Full Example

```typescript
import { AltudeGasStation } from '@altude/gasstation'

// 1. Initialize the client
const client = new AltudeGasStation({
  apiKey: process.env.ALTUDE_API_KEY!,
  network: 'devnet',
})

// 2. Get a recent blockhash from the relay
const { blockhash } = await client.getBlockhash()

// 3. Check balances
const balance = await client.getBalance({
  address: 'YOUR_WALLET_ADDRESS',
})

console.log(blockhash, balance)
```

### Python SDK – Full Example

```python
from kinetic_sdk import KineticSdk, Commitment

# Initialize
client = KineticSdk.setup(
    environment='devnet',
    index=1,
    endpoint='https://your-altude-endpoint',
)

keypair = client.keypair.random()

# Create account
client.create_account(owner=keypair, commitment=Commitment.FINALIZED)

# Transfer
client.make_transfer(
    sender=keypair,
    destination='RecipientPublicKeyBase58',
    amount='100',
    commitment=Commitment.CONFIRMED,
)
```

### Swift (iOS) – Key Operations

```swift
import KineticSwift

let client = try await KineticSdk.setup(
    config: KineticSdkConfig(
        environment: "devnet",
        index: 1,
        endpoint: "https://your-altude-endpoint"
    )
)

let keypair = Keypair.random()
try await client.createAccount(owner: keypair, commitment: .finalized)
try await client.makeTransfer(
    sender: keypair,
    destination: "RecipientPublicKeyBase58",
    amount: "100",
    commitment: .confirmed
)
```

### Kotlin (Android) – Key Operations

```kotlin
val client = KineticSdk.setup(
    KineticSdkConfig(
        environment = "devnet",
        index = 1,
        endpoint = "https://your-altude-endpoint"
    )
)

val keypair = Keypair.random()
client.createAccount(owner = keypair, commitment = Commitment.FINALIZED)
client.makeTransfer(
    sender = keypair,
    destination = "RecipientPublicKeyBase58",
    amount = "100",
    commitment = Commitment.CONFIRMED
)
```

## Architecture

```
┌──────────────────────────────────────────────────────────┐
│                       Client App                         │
│   (Web / iOS / Android / Flutter / Unity)                │
│                                                          │
│   Altude SDK  ──────►  Altude REST API                   │
└──────────────────────────────────────────────────────────┘
                              │
                              ▼
                   ┌──────────────────┐
                   │  Altude Platform │
                   │  - App Registry  │
                   │  - Fee Payer     │
                   │  - Transaction   │
                   │    Queue         │
                   │  - Dashboard     │
                   └──────────────────┘
                              │
                              ▼
                   ┌──────────────────┐
                   │  Solana Network  │
                   │  (devnet /       │
                   │   mainnet)       │
                   └──────────────────┘
```

**Data flow for a gasless transfer:**
1. App calls `makeTransfer` via SDK.
2. SDK serialises the transaction and sends it to the Altude API.
3. Altude API partially signs the transaction with the app's fee-payer keypair.
4. The user's keypair signs the transaction client-side (keys never leave the device).
5. The fully-signed transaction is submitted to the Solana network.
6. Altude monitors for commitment and returns the transaction signature.

## Key Concepts

| Term          | Definition                                                                                          |
|---------------|-----------------------------------------------------------------------------------------------------|
| App Index     | Unique integer identifier for a registered Altude application. Required for all API/SDK calls.     |
| Environment   | `devnet` for testing (free airdrops available), `mainnet` for production.                          |
| Commitment    | Transaction finality: `Processed` (fast, not guaranteed), `Confirmed`, or `Finalized` (slowest, safest). |
| Fee Payer     | The Solana account (funded by the developer) that covers SOL transaction fees on behalf of users.   |
| Keypair       | A public/private key pair. Public key is the on-chain account address.                             |
| Mnemonic      | BIP-39 word phrase used to generate a deterministic keypair. User-held; never shared with Altude.  |
| Mint          | The SPL token mint address specifying which token is being transferred.                             |
| SPL Token     | Solana Program Library token standard—analogous to ERC-20 on Ethereum.                             |

## Comparison with Alternatives

| Feature                         | Altude          | Privy          | Dynamic        | Turnkey        | Self-hosted Relayer |
|---------------------------------|-----------------|----------------|----------------|----------------|---------------------|
| Gasless transactions (native)   | ✅ Yes          | ❌ No          | ❌ No          | ❌ No          | ⚠️ Custom build     |
| True self-custody               | ✅ Yes          | ⚠️ Partial     | ⚠️ Partial     | ✅ Yes         | ✅ Yes              |
| Solana-native                   | ✅ Yes          | ⚠️ Multi-chain | ⚠️ Multi-chain | ⚠️ Multi-chain | ✅ Yes              |
| SDKs (web + mobile + games)     | ✅ All          | ⚠️ Web only    | ⚠️ Web only    | ⚠️ Web/mobile  | ❌ None             |
| Managed dashboard               | ✅ Yes          | ✅ Yes         | ✅ Yes         | ✅ Yes         | ❌ None             |
| No vendor key custody           | ✅ Yes          | ❌ No          | ❌ No          | ✅ Yes         | ✅ Yes              |

## Pricing

Altude offers a free tier for development and early-stage apps, with paid plans scaling to enterprise volume. See https://altude.so/pricing for current tiers and limits.

## Links

- Website: https://altude.so
- Documentation: https://docs.altude.so
- Pricing: https://altude.so/pricing
- Changelog: https://altude.so/changelog
- How It Works: https://altude.so/how-it-works
- Compare: https://altude.so/compare
- Concise LLM Summary: https://altude.so/llms.txt