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
}