wankmi 🟢

Reactive React hooks for building Solana dApps.

Wallets, balances, tokens, transactions — all the hooks you need, none of the boilerplate. Built from scratch for Solana's account model. Not an Ethereum port.

Install

npm install @wankmi/wankmi
# or
pnpm add @wankmi/wankmi
# or
yarn add @wankmi/wankmi

Quick start

Wrap your app with WankmiProvider:

import { WankmiProvider } from '@wankmi/wankmi'
import { PhantomAdapter } from '@wankmi/wankmi/adapters'

const config = {
  network: 'mainnet-beta',
  wallets: [new PhantomAdapter()],
  autoConnect: true,
}

function App() {
  return (
    <WankmiProvider config={config}>
      <YourApp />
    </WankmiProvider>
  )
}

Then use hooks anywhere in your tree:

import { useWallet, useSolBalance } from '@wankmi/wankmi'

function Dashboard() {
  const { publicKey, connected, connect } = useWallet()
  const { data: balance } = useSolBalance({ watch: true })

  if (!connected) {
    return <button onClick={connect}>Connect Wallet</button>
  }

  return (
    <div>
      <p>{publicKey?.toBase58()}</p>
      <p>{balance?.formatted}</p>
    </div>
  )
}

Hooks

Core

| Hook | Description | |---|---| | useWallet() | Wallet connection state, publicKey, connect/disconnect | | useConnection() | The active Connection instance |

Balances & Tokens

| Hook | Description | |---|---| | useSolBalance(options) | SOL balance, optionally reactive via WebSocket | | useTokenAccounts(options) | All SPL token accounts for an address | | useMint(options) | Mint info (decimals, supply, authorities) |

Transactions

| Hook | Description | |---|---| | useSendTransaction() | Build, sign, send and confirm transactions | | useSignMessage() | Sign arbitrary messages (e.g. SIWS auth) |

API Reference

useWallet()

const {
  wallet,           // WalletAdapter | null
  wallets,          // WalletAdapter[]
  publicKey,        // PublicKey | null
  connected,        // boolean
  connecting,       // boolean
  disconnecting,    // boolean
  select,           // (name: string) => void
  connect,          // () => Promise<void>
  disconnect,       // () => Promise<void>
  signTransaction,  // WalletAdapter['signTransaction'] | null
  signAllTransactions,
  signMessage,
} = useWallet()

useSolBalance(options)

const { data, isLoading, isError, refetch } = useSolBalance({
  address?: PublicKey | string,  // defaults to connected wallet
  watch?: boolean,               // WebSocket subscription (default: false)
  refetchInterval?: number,
  enabled?: boolean,
})

// data: { lamports: bigint, sol: number, formatted: string }

useTokenAccounts(options)

const { data, isLoading } = useTokenAccounts({
  address?: PublicKey | string,
  mint?: PublicKey | string,     // filter to a specific mint
  enabled?: boolean,
})

// data: TokenAccount[]
// TokenAccount: { mint, address, amount, decimals, uiAmount, formatted }

useMint(options)

const { data } = useMint({
  mint: PublicKey | string,
})

// data: { address, decimals, supply, mintAuthority, freezeAuthority, isInitialized }

useSendTransaction()

const { sendTransaction, status, signature, isLoading, error, reset } = useSendTransaction()

// status: 'idle' | 'signing' | 'sending' | 'confirming' | 'confirmed' | 'error'

const { signature } = await sendTransaction(transaction, {
  skipPreflight?: boolean,
  preflightCommitment?: 'processed' | 'confirmed' | 'finalized',
  maxRetries?: number,
})

useSignMessage()

const { signMessage, result, isLoading } = useSignMessage()

const { signature, signatureBase58 } = await signMessage('Sign in to my dApp')

Wallet Adapters

import { PhantomAdapter, BackpackAdapter, SolflareAdapter } from '@wankmi/wankmi/adapters'

WankmiProvider Config

interface WankmiConfig {
  network: 'mainnet-beta' | 'devnet' | 'testnet' | 'localnet'
  endpoint?: string | { http: string; ws?: string }  // custom RPC
  wallets: WalletAdapter[]
  autoConnect?: boolean      // default: false
  staleTime?: number         // TanStack Query stale time, default: 30_000ms
  commitment?: 'processed' | 'confirmed' | 'finalized'  // default: 'confirmed'
}

License

MIT