Communitygithub.com

chambaz/solanaui

Intègre les composants SolanaUI dans les applications Solana. À utiliser lors de la création d'interfaces de swap, de pages de trading perpétuels, de tableaux de bord de prêt, de marketplaces NFT, de vues de portefeuille, de pages de staking ou de toute interface DeFi Solana. Fournit 30 composants React prêts à l'emploi avec des props TypeScript, des modèles de mise en page et des conseils d'intégration.

Qu'est-ce que solanaui ?

SolanaUI est une bibliothèque de composants React spécialisée pour Solana, construite sur shadcn/ui, Radix UI et Tailwind CSS. Elle offre 30 composants UI prêts à l'emploi pour accélérer le développement d'interfaces DeFi, de plateformes de trading, de marketplaces NFT et plus encore. Tous les composants sont purement présentationnels : ils acceptent des données via des props et émettent des callbacks, sans aucune dépendance blockchain, adaptateur de portefeuille ou importation SDK. Les composants incluent notamment SwapBox, TradeBox, PositionTable, PriceChart, NFTCard, OrderBook et bien d'autres couvrant les cas d'usage courants de Solana. L'intégration se fait via le registre shadcn/ui : une commande permet d'ajouter un composant au projet, et les dépendances sont résolues automatiquement. Les développeurs connectent simplement leurs données en faisant correspondre les props des composants à leurs sources de données (API, on-chain, etc.), et gèrent les actions utilisateur via les callbacks comme `onSubmit` ou `onSelect`. SolanaUI est idéal pour construire rapidement des interfaces Solana sans se soucier de la couche UI, avec une documentation complète et des exemples d'intégration concrets.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add chambaz/solanaui

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait solanaui ?

Une bibliothèque de composants React axée sur Solana, construite sur shadcn/ui, Radix UI et Tailwind CSS. Tous les composants sont purement présentationnels : ils acceptent des données via des props et émettent des callbacks. Ils n'ont aucune dépendance blockchain, aucun adaptateur de portefeuille et aucune importation SDK. C'est vous qui les branchez sur votre propre couche de données.

Quand l'utiliser

Utilisez les composants SolanaUI lors de la création d'interfaces d'applications Solana. Les composants gèrent la couche UI — rendu des icônes de jetons, formatage des prix, affichage des tableaux et graphiques — tandis que votre code gère la récupération des données, les connexions aux portefeuilles et la logique des transactions.

Intégration typique : récupérez les données depuis votre API ou une source on-chain, transformez-les pour qu'elles correspondent à l'interface des props du composant, puis passez-les. Branchez les callbacks (onSubmit, onSelect, onValueChange) pour déclencher votre logique applicative.

Installation

Nécessite que shadcn/ui soit initialisé dans votre projet (components.json doit exister). Si ce n'est pas le cas, exécutez d'abord pnpm dlx shadcn@latest init.

Ajoutez le registre SolanaUI à votre components.json :

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

Installez ensuite les composants :

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

Les primitives shadcn/ui nécessaires (Card, Dialog, Button, etc.) sont résolues automatiquement comme dépendances du registre. Les composants dépendent également de l'utilitaire cn() de @/lib/utils.

Conventions d'importation

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";

Modèles d'intégration

Connexion aux sources de données

Les composants acceptent des données simples via des props. Mappez vos données aux formes des props :

// Votre source de données (API, on-chain, gestion d'état, etc.)
const positions = usePositions(); // votre hook

// Mappage à la forme des props du composant
<PositionTable
  positions={positions.map(p => ({
    symbol: p.market.baseSymbol,
    icon: p.market.baseIconUrl,       // utilisez vos propres URLs d'icônes
    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)}
/>

Icônes de jetons

Les composants acceptent les URLs d'icônes sous forme de chaînes. Utilisez la source d'icônes que votre projet a déjà — votre propre CDN, un registre de jetons ou un service de métadonnées.

Si vous avez besoin d'icônes de substitution pour le prototypage, ces URLs CDN publiques fonctionnent :

  • 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

Gestion des callbacks

Les composants émettent des callbacks pour les actions utilisateur. Branchez-les à votre logique applicative :

<SwapBox
  tokens={availableTokens}
  defaultFromToken="USDC"
  defaultToToken="SOL"
  fromBalance={wallet.usdcBalance}
  details={quoteDetails}
  submitLabel="Swap"
  // Votre logique d'exécution de swap
  onSubmit={() => executeSwap(fromToken, toToken, amount)}
/>

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

Catalogue de composants (30 composants)

ActionBox (action-box)

Formulaire d'action à entrée unique pour le staking, le prêt, le dépôt LP, le bridging. La contrepartie polyvalente de 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)

Liste chronologique d'activités avec icônes, horodatages (objets Date) et valeurs. Utilise formatDistanceToNow de date-fns pour le temps relatif.

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

AddressDisplay (address-display)

Adresse Solana tronquée avec copie dans le presse-papiers et lien optionnel vers l'explorateur. explorerUrl est une URL de base ; l'adresse est ajoutée automatiquement.

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

AuthCard (auth-card)

Carte de connexion avec champ email optionnel, boutons de connexion sociale et boutons de fournisseur de portefeuille.

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

HealthBar (health-bar)

Barre de progression dégradée (rouge à vert) avec valeur en pourcentage colorée.

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

LeverageSlider (leverage-slider)

Curseur pour sélectionner l'effet de levier de trading avec boutons raccourcis min/max.

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

NFTCard (nft-card)

Carte affichant l'image NFT, le nom, la collection et le prix avec états de chargement/erreur.

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

OrderBook (order-book)

Carnet d'ordres de trading avec niveaux d'offre/demande, tailles, cumuls, spread, prix médian et barres de profondeur.

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

OrderForm (order-form)

Formulaire d'ordre TP/SL pour les positions ouvertes. Entrées TP doubles (prix + % de gain), entrées SL doubles (prix + % de perte). Passez entryPrice pour synchroniser automatiquement les champs de prix et de pourcentage.

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)

Carte polyvalente pour les pools à jeton unique ou multi-jetons. Affiche des icônes empilées, un prix optionnel, une description, une grille de métriques, un graphique sparkline et un emplacement pour enfants.

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)

Tableau de données avec icônes de jetons (un ou plusieurs par ligne), colonnes définies par l'utilisateur, triables et actions de ligne optionnelles. Fonctionne pour les listes de pools, les tableaux de jetons, les tableaux de validateurs.

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)

Carte affichant une position DeFi avec icône de jeton, montant, valeur USD, APY et pied de page d'action optionnel.

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

PositionTable (position-table)

Tableau des positions de trading ouvertes avec type (long/short), icône de l'actif, taille, effet de levier, prix d'entrée/actuel et P&L coloré. Colonnes d'action intégrées pour l'édition TP/SL et la fermeture avec interfaces de dialogue.

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)

Graphique en aires pour l'historique du prix d'un jeton ou de la valeur d'un portefeuille avec axes, grille, remplissage dégradé et infobulles.

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

SparklineChart (sparkline-chart)

Sparkline minimal en ligne avec coloration positive/négative automatique et étiquette de pourcentage de changement.

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

StatCard (stat-card)

Carte d'affichage de statistiques avec étiquette, valeur, icône optionnelle et badge de tendance optionnel.

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

SwapBox (swap-box)

Formulaire de swap bilatéral avec bouton d'inversion, lignes de détail et action de soumission. Le bouton d'inversion échange les jetons sélectionnés sur place (les étiquettes restent fixes).

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)

Menu déroulant avec recherche pour sélectionner un jeton, avec icônes et sélection par coche.

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

TokenCommand (token-command)

Dialogue de commande Cmd+K pour rechercher et sélectionner des jetons. Passez soit tokens (liste plate) soit groups (sectionné), pas les deux.

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)

Image d'icône de jeton circulaire avec squelette de chargement et fallback d'erreur.

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

TokenIconGroup (token-icon-group)

Icônes de jetons empilées qui se chevauchent pour les paires LP ou les groupes multi-jetons. Affiche un badge +N lorsque le maximum est dépassé.

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

TokenInput (token-input)

Entrée numérique avec sélecteur de jeton intégré, solde du portefeuille, boutons Moitié/Max et affichage de la valeur USD. Formate avec des séparateurs de milliers. onValueChange reçoit la chaîne brute non formatée.

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)

Formulaire de trading perpétuel/marge avec bascule long/short, entrée de jeton, curseur d'effet de levier, lignes de détail et soumission. Pour les actions non commerciales, utilisez 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)

Groupe de bascule pour sélectionner la direction du trading (Long/Short ou Acheter/Vendre) avec des états codés par couleur.

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

TradeChart (trade-chart)

Graphique en chandeliers propulsé par TradingView lightweight-charts avec prise en charge du thème sombre/clair.

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

TrendBadge (trend-badge)

Petit badge coloré avec icône de tendance pour les changements positifs (vert) ou négatifs (rouge).

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

TxnTable (txn-table)

Tableau des transactions avec liens de signature tronqués, horodatages relatifs (objets Date, via date-fns), badges d'action et montants de jetons.

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

Skills associés