Communitygithub.com

chambaz/solanaui

Integriert SolanaUI-Komponenten in Solana-Apps. Verwenden Sie es beim Erstellen von Swap-Oberflächen, Perps-Handelsseiten, Lending-Dashboards, NFT-Marktplätzen, Portfolio-Ansichten, Staking-Seiten oder jeder anderen Solana-DeFi-Benutzeroberfläche. Bietet 30 produktionsreife React-Komponenten mit TypeScript-Props, Layout-Mustern und Integrationsanleitung.

Was ist solanaui?

Dieses Skill ermöglicht es KI-Agenten (wie Claude Code, Cursor, Codex), nahtlos SolanaUI-Komponenten in Solana-Apps zu integrieren. SolanaUI ist eine React-Komponentenbibliothek, die auf shadcn/ui, Radix UI und Tailwind CSS basiert und speziell für Solana-DeFi-Schnittstellen entwickelt wurde. Die Bibliothek enthält 30 produktionsreife Komponenten – darunter SwapBox, OrderBook, PositionTable, TradeBox, PriceChart und viele mehr – die Daten über Props akzeptieren und über Callbacks kommunizieren. Es gibt keine Blockchain-Abhängigkeiten, keine Wallet-Adapter und keine SDK-Importe; der Entwickler oder Agent verbindet sie mit seiner eigenen Datenebene. Das Skill ist nützlich für den Bau von Swap-Oberflächen, Perps-Handelsseiten, Lending-Dashboards, NFT-Marktplätzen und anderen Solana-DeFi-Anwendungen. Die Installation erfolgt über das Hinzufügen einer Registry zur `components.json` und die Verwendung des `shadcn`-CLI-Befehls. Das Skill enthält detaillierte Integrationsmuster, Importkonventionen und ein vollständiges Komponentenverzeichnis, das KI-Agenten als Blaupause für die UI-Erstellung dient.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add chambaz/solanaui

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Was macht solanaui?

Eine auf Solana fokussierte React-Komponentenbibliothek, die auf shadcn/ui, Radix UI und Tailwind CSS basiert. Alle Komponenten sind präsentational – sie akzeptieren Daten über Props und geben Callbacks aus. Sie haben keine Blockchain-Abhängigkeiten, keine Wallet-Adapter und keine SDK-Importe. Sie verbinden sie mit Ihrer eigenen Datenebene.

Wann verwenden

Verwenden Sie SolanaUI-Komponenten beim Erstellen von Solana-App-Oberflächen. Die Komponenten übernehmen die UI-Ebene – rendern Token-Symbole, formatieren Preise, zeigen Tabellen und Diagramme an – während Ihr Code das Datenabrufen, Wallet-Verbindungen und die Transaktionslogik übernimmt.

Typische Integration: Rufen Sie Daten von Ihrer API oder einer On-Chain-Quelle ab, transformieren Sie sie in die Props-Schnittstelle der Komponente und übergeben Sie sie. Hängen Sie Callbacks (onSubmit, onSelect, onValueChange) ein, um Ihre Anwendungslogik auszulösen.

Installation

Erfordert, dass shadcn/ui in Ihrem Projekt initialisiert ist (components.json muss existieren). Falls nicht, führen Sie zuerst pnpm dlx shadcn@latest init aus.

Fügen Sie die SolanaUI-Registry zu Ihrer components.json hinzu:

{
  "registries": {
    "@solanaui": "https://solanaui.dev/r/{name}.json"
  }
}

Installieren Sie dann die Komponenten:

pnpm dlx shadcn@latest add @solanaui/swap-box

Alle erforderlichen shadcn/ui-Primitive (Card, Dialog, Button usw.) werden automatisch als Registry-Abhängigkeiten aufgelöst. Komponenten hängen auch von der cn()-Utility aus @/lib/utils ab.

Import-Konventionen

import { SwapBox } from "@/components/sol/swap-box";
import { PoolTable } from "@/components/sol/pool-table";
import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
import { Button } from "@/components/ui/button";

Integrationsmuster

Verbinden mit Datenquellen

Komponenten akzeptieren einfache Daten über Props. Bilden Sie Ihre Daten auf die Props-Formen ab:

// Ihre Datenquelle (API, On-Chain, State-Management usw.)
const positions = usePositions(); // Ihr Hook

// Auf Props-Form der Komponente abbilden
<PositionTable
  positions={positions.map(p => ({
    symbol: p.market.baseSymbol,
    icon: p.market.baseIconUrl,       // Verwenden Sie Ihre eigenen Icon-URLs
    side: p.direction,
    size: formatNumber(p.size),
    value: formatUsd(p.notionalValue),
    leverage: `${p.leverage}x`,
    entryPrice: formatUsd(p.entryPrice),
    markPrice: formatUsd(p.currentPrice),
    pnl: formatPnl(p.unrealizedPnl),
    pnlPercent: formatPercent(p.unrealizedPnlPercent),
    pnlTrend: p.unrealizedPnl >= 0 ? "up" : "down",
  }))}
  onClosePosition={(pos) => closePosition(pos.symbol)}
  onEditTpSl={(pos, values) => updateTpSl(pos.symbol, values)}
/>

Token-Symbole

Komponenten akzeptieren Icon-URLs als Strings. Verwenden Sie die Icon-Quelle, die Ihr Projekt bereits hat – Ihr eigenes CDN, ein Token-Register oder einen Metadaten-Dienst.

Wenn Sie Platzhalter-Icons für das Prototyping benötigen, funktionieren diese öffentlichen CDN-URLs:

  • SOL: https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/So11111111111111111111111111111111111111112/logo.png
  • USDC: https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png
  • BONK: https://arweave.net/hQiPZOsRZXGXBJd_82PhVdlM_hACsT_q6wqwf5cSY7I
  • JitoSOL: https://storage.googleapis.com/token-metadata/JitoSOL-256.png
  • mSOL: https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So/logo.png

Umgang mit Callbacks

Komponenten geben Callbacks für Benutzeraktionen aus. Verbinden Sie diese mit Ihrer Anwendungslogik:

<SwapBox
  tokens={availableTokens}
  defaultFromToken="USDC"
  defaultToToken="SOL"
  fromBalance={wallet.usdcBalance}
  details={quoteDetails}
  submitLabel="Swap"
  // Ihre Swap-Ausführungslogik
  onSubmit={() => executeSwap(fromToken, toToken, amount)}
/>

<ActionBox
  tokens={supportedTokens}
  label="Stake"
  balance={wallet.solBalance}
  details={stakingDetails}
  submitLabel="Stake SOL"
  onSubmit={() => submitStakeTransaction(selectedToken, amount)}
/>

Komponenten-Katalog (30 Komponenten)

ActionBox (action-box)

Eingabeformular mit einer Aktion für Staking, Lending, LP-Einzahlung, Bridging. Das vielseitige Gegenstück zu TradeBox.

interface ActionBoxProps {
  tokens: { icon: string; symbol: string }[];
  defaultToken?: string;
  balance?: string;
  label?: string;
  details?: { label: string; value: string; className?: string }[];
  submitLabel?: string;
  onSubmit?: () => void;
  className?: string;
}

ActivityFeed (activity-feed)

Chronologische Aktivitätsliste mit Symbolen, Zeitstempeln (Date-Objekten) und Werten. Verwendet date-fns formatDistanceToNow für relative Zeitangaben.

interface ActivityFeedProps {
  items: { icon?: string; title: string; description?: string; timestamp: Date; value?: string }[];
  className?: string;
}

AddressDisplay (address-display)

Gekürzte Solana-Adresse mit Kopieren-in-Zwischenablage und optionalem Explorer-Link. explorerUrl ist eine Basis-URL; die Adresse wird automatisch angehängt.

interface AddressDisplayProps {
  address: string; truncate?: boolean; truncateChars?: [number, number];
  copyable?: boolean; explorerUrl?: string; className?: string;
}

AuthCard (auth-card)

Anmeldekarte mit optionaler E-Mail-Eingabe, Social-Login-Buttons und Wallet-Provider-Buttons.

interface AuthCardProps {
  title?: string; description?: string; showEmail?: boolean;
  socialProviders?: { name: string; icon: React.ReactNode }[];
  walletProviders?: { name: string; icon: React.ReactNode }[];
}

HealthBar (health-bar)

Gradienten-Fortschrittsbalken (rot-zu-grün) mit farbigem Prozentwert.

interface HealthBarProps { value: number; label?: string; showValue?: boolean; className?: string }

LeverageSlider (leverage-slider)

Schieberegler zur Auswahl des Handelshebels mit Min-/Max-Schnellzugriffstasten.

interface LeverageSliderProps {
  min?: number; max?: number; step?: number; value?: number[];
  defaultValue?: number[]; onValueChange?: (value: number[]) => void; className?: string;
}

NFTCard (nft-card)

Karte zur Anzeige von NFT-Bild, -Name, -Sammlung und -Preis mit Lade-/Fehlerzuständen.

interface NFTCardProps {
  name: string; image: string; collection?: string;
  price?: string; currency?: string; className?: string;
}

OrderBook (order-book)

Handelsorderbuch mit Gebots-/Briefkursen, Größen, kumulativen Summen, Spread, Mittelkurs und Tiefenbalken.

interface OrderBookProps {
  bids: { price: number; size: number }[];
  asks: { price: number; size: number }[];
  className?: string;
}

OrderForm (order-form)

TP/SL-Orderformular für offene Positionen. Doppelte TP-Eingaben (Preis + Gewinn-%), doppelte SL-Eingaben (Preis + Verlust-%). Übergeben Sie entryPrice, um die automatische Synchronisation zwischen Preis- und Prozentfeldern zu aktivieren.

interface OrderFormProps {
  title?: string; description?: string; entryPrice?: number;
  details?: { label: string; value: string; className?: string }[];
  onSubmit?: (values: { tpPrice: string; tpPercent: string; slPrice: string; slPercent: string }) => void;
  className?: string;
}

PoolCard (pool-card)

Vielseitige Karte für Single-Token- oder Multi-Token-Pools. Zeigt gestapelte Symbole, optionalen Preis, Beschreibung, Metrikraster, Sparkline-Diagramm und Children-Slot.

interface PoolCardProps {
  tokens: { icon: string; symbol: string }[]; name?: string; price?: string; description?: string;
  metrics?: { label: string; value: string; highlight?: boolean; className?: string }[];
  series?: { time: string; value: number }[]; children?: React.ReactNode; className?: string;
}

PoolTable (pool-table)

Datentabelle mit Token-Symbolen (eines oder mehrere pro Zeile), benutzerdefinierten Spalten, sortierbar und optionalen Zeilenaktionen. Funktioniert für Pool-Listen, Token-Tabellen, Validator-Tabellen.

interface PoolTableProps {
  columns: { key: string; label: string; className?: string }[];
  rows: { icons: { src: string; alt?: string }[]; name?: string; data: Record<string, string> }[];
  actions?: React.ReactNode[]; className?: string;
}

PositionCard (position-card)

Karte zur Darstellung einer DeFi-Position mit Token-Symbol, Betrag, USD-Wert, APY und optionalem Aktions-Footer.

interface PositionCardProps {
  symbol: string; icon: string; amount: string; value: string;
  apy?: string; trend?: "up" | "down"; children?: React.ReactNode; className?: string;
}

PositionTable (position-table)

Tabelle offener Handels-Positionen mit Typ (Long/Short), Asset-Symbol, Größe, Hebel, Einstiegs-/Marktpreisen und farbigem Gewinn/Verlust. Integrierte TP/SL-Bearbeitungs- und Schließen-Aktionsspalten mit Dialog-UIs.

interface PositionTablePosition {
  symbol: string; icon: string; side: "long" | "short";
  size: string; value: string; leverage: string;
  entryPrice: string; markPrice: string; liquidationPrice?: string;
  pnl: string; pnlPercent?: string; pnlTrend?: "up" | "down";
}
interface PositionTableProps {
  positions: PositionTablePosition[];
  onEditTpSl?: (position: PositionTablePosition, values: { tpPrice: string; tpPercent: string; slPrice: string; slPercent: string }) => void;
  onClosePosition?: (position: PositionTablePosition) => void;
  className?: string;
}

PriceChart (price-chart)

Flächendiagramm für Token-Preis- oder Portfolio-Wertverlauf mit Achsen, Raster, Verlaufsfüllung und Tooltips.

interface PriceChartProps {
  title?: string; description?: string;
  series: { time: string; value: number }[]; className?: string;
}

SparklineChart (sparkline-chart)

Minimale Inline-Sparkline mit automatischer Positiv-/Negativ-Färbung und Prozentänderungs-Label.

interface SparklineChartProps { series: { time: string; value: number }[]; className?: string }

StatCard (stat-card)

Statistik-Anzeigekarte mit Label, Wert, optionalem Symbol und optionalem Trend-Abzeichen.

interface StatCardProps {
  label: string; value: string; change?: string;
  trend?: "up" | "down"; icon?: React.ReactNode; className?: string;
}

SwapBox (swap-box)

Zweiseitiges Token-Swap-Formular mit Umschalt-Taste, Detailzeilen und Aktion zum Absenden. Mit der Umschalt-Taste werden die ausgewählten Token direkt vertauscht (Labels bleiben fest).

interface SwapBoxProps {
  tokens: { icon: string; symbol: string }[];
  defaultFromToken?: string; defaultToToken?: string;
  fromBalance?: string; toBalance?: string; fromLabel?: string; toLabel?: string;
  details?: { label: string; value: string; className?: string }[];
  submitLabel?: string; onSubmit?: () => void; className?: string;
}

TokenCombobox (token-combobox)

Durchsuchbares Dropdown zur Auswahl eines Tokens mit Symbolen und Häkchen-Auswahl.

interface TokenComboboxProps {
  tokens: { icon: string; symbol: string }[];
  defaultValue?: string; onSelect?: (token: { icon: string; symbol: string }) => void; className?: string;
}

TokenCommand (token-command)

Cmd+K-Befehlsdialog zum Suchen und Auswählen von Token. Übergeben Sie entweder tokens (flache Liste) oder groups (abschnittsweise), nicht beides.

type TokenCommandProps = {
  onSelect?: (token: { icon: string; symbol: string }) => void; className?: string;
} & (
  | { tokens: { icon: string; symbol: string }[]; groups?: never }
  | { groups: { heading: string; tokens: { icon: string; symbol: string }[] }[]; tokens?: never }
)

TokenIcon (token-icon)

Rundes Token-Symbol-Bild mit Lade-Skeleton und Fehler-Fallback.

type TokenIconProps = { src: string; alt: string; width?: number; height?: number; className?: string }

TokenIconGroup (token-icon-group)

Gestapelte, überlappende Token-Symbole für LP-Paare oder Multi-Token-Gruppen. Zeigt +N-Abzeichen an, wenn das Maximum überschritten wird.

interface TokenIconGroupProps {
  tokens: { src: string; alt?: string }[]; size?: number; overlap?: number; max?: number; className?: string;
}

TokenInput (token-input)

Numerische Eingabe mit integriertem Token-Selektor, Wallet-Guthaben, Halb-/Max-Buttons und USD-Wert-Anzeige. Formatiert mit Tausendertrennzeichen. onValueChange erhält den rohen, unformatierten String.

interface TokenInputProps {
  tokens: { icon: string; symbol: string }[]; defaultToken?: string; balance?: string;
  value?: string; usdValue?: string; onValueChange?: (value: string) => void;
  onTokenSelect?: (token: { icon: string; symbol: string }) => void; className?: string;
}

TradeBox (trade-box)

Perps/Margin-Handelsformular mit Long/Short-Umschalter, Token-Eingabe, Hebel-Schieberegler, Detailzeilen und Absendeaktion. Für nicht-handelsbezogene Aktionen verwenden Sie ActionBox.

interface TradeBoxProps {
  tokens: { icon: string; symbol: string }[]; defaultToken?: string; balance?: string;
  labels?: [string, string]; defaultSide?: string;
  leverageMin?: number; leverageMax?: number; leverageDefault?: number; leverageStep?: number;
  details?: { label: string; value: string; className?: string }[];
  submitLabel?: string; onSubmit?: () => void; className?: string;
}

TradeButtons (trade-buttons)

Umschaltgruppe zur Auswahl der Handelsrichtung (Long/Short oder Buy/Sell) mit farbcodierten Zuständen.

interface TradeButtonsProps {
  defaultValue?: string; value?: string; onValueChange?: (value: string) => void;
  labels?: [string, string]; className?: string;
}

TradeChart (trade-chart)

Kerzenchart basierend auf TradingView lightweight-charts mit Unterstützung für Dark-/Light-Theme.

interface TradeChartProps {
  data: { time: string | number; open: number; high: number; low: number; close: number }[];
  visibleBars?: number; className?: string;
}

TrendBadge (trend-badge)

Kleines farbiges Abzeichen mit Trend-Symbol für positive (grün) oder negative (rot) Änderungen.

interface TrendBadgeProps { trend?: "up" | "down"; children: React.ReactNode; className?: string }

TxnTable (txn-table)

Transaktionstabelle mit gekürzten Signatur-Links, relativen Zeitstempeln (Date-Objekte, via date-fns), Aktions-Abzeichen und Token-Beträgen.

interface TxnTableProps {
  transactions: {
    signature: string; timestamp: Date; action: string; token: string;
    tokenIcon?: string; amount: string; value?: string; explorerUrl?: string;
  }[];
  className?: string;

Verwandte Skills