@notdotmarket/dbc-hooks

React hooks for the Dynamic Bonding Curve SDK, built with React Query and fully integrated with Reown AppKit for seamless wallet management.

Features

- ✅ Reown AppKit Integration - Built-in support for Reown AppKit at the provider level
- ✅ Universal Wallet Support - Works with any Solana wallet (Phantom, Solflare, Backpack, etc.)
- ✅ Plug and Play - No manual wallet adapter management needed
- ✅ React Query Powered - Automatic caching, refetching, and state management
- ✅ Complete SDK Coverage - 16 hooks covering all Dynamic Bonding Curve operations
- ✅ TypeScript First - Full type safety and IntelliSense support
- ✅ Multiple Swap Modes - ExactIn, ExactOut, and PartialFill support

Installation

``bash


Install the hooks package

`tsx
import { createAppKit } from '@reown/appkit/react'
import { SolanaAdapter } from '@reown/appkit-adapter-solana'
import { DbcAppKitProvider } from '@notdotmarket/dbc-hooks'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { Connection } from '@solana/web3.js'
import { solanaDevnet } from '@reown/appkit/networks'

// 1. Setup React Query
const queryClient = new QueryClient()

// 2. Setup Reown AppKit
const projectId = 'YOUR_PROJECT_ID' // Get from https://dashboard.reown.com

const solanaAdapter = new SolanaAdapter({
networks: [solanaDevnet]
})

createAppKit({
adapters: [solanaAdapter],
networks: [solanaDevnet],
projectId,
metadata: {
name: 'Your DApp',
description: 'Your DApp Description',
url: 'https://yourdapp.com',
icons: ['https://yourdapp.com/icon.png']
},
features: {
analytics: true
}
})

// 3. Setup DBC with Solana connection
const connection = new Connection('https://api.devnet.solana.com')

function App() {
return (





)
}
`

$3

`tsx
import { useAppKitAccount, useAppKitProvider } from '@reown/appkit/react'
import { useSwap, usePoolInfo } from '@notdotmarket/dbc-hooks'
import { PublicKey } from '@solana/web3.js'
import BN from 'bn.js'

function TradingComponent() {
// Get wallet state from Reown AppKit
const { address, isConnected } = useAppKitAccount()
const { walletProvider } = useAppKitProvider('solana')

// Get pool info
const { data: poolInfo } = usePoolInfo(poolAddress)

// Setup swap mutation
const swap = useSwap()

const handleSwap = async () => {
if (!isConnected || !walletProvider || !address) {
alert('Please connect your wallet')
return
}

try {
const result = await swap.mutateAsync({
wallet: walletProvider, // Pass Reown wallet provider directly
pool: new PublicKey(poolAddress),
owner: new PublicKey(address),
amountIn: new BN(1000000),
minimumAmountOut: new BN(900000),
swapBaseForQuote: false,
referralTokenAccount: null,
})

console.log('Swap successful!', result.signature)
} catch (error) {
console.error('Swap failed:', error)
}
}

return (


`tsx
import { useAppKitAccount, useAppKitProvider } from '@reown/appkit/react'
import {
useSwap,
useSwapQuote,
usePoolInfo,
useFeeBreakdown,
useWithdraw
} from '@notdotmarket/dbc-hooks'
import { PublicKey } from '@solana/web3.js'
import BN from 'bn.js'

function CompleteTrading() {
const { address, isConnected } = useAppKitAccount()
const { walletProvider } = useAppKitProvider('solana')

const poolAddress = new PublicKey('YOUR_POOL_ADDRESS')

// Fetch pool data
const { data: poolInfo, isLoading } = usePoolInfo(poolAddress)
const { data: fees } = useFeeBreakdown(poolAddress)

// Get swap quote
const { data: quote } = useSwapQuote({
poolAddress,
amountIn: new BN(1000000),
swapBaseForQuote: false,
slippageBps: 100,
hasReferral: false,
})

// Mutations
const swap = useSwap()
const withdraw = useWithdraw()

const handleSwap = async () => {
if (!walletProvider || !address) return

await swap.mutateAsync({
wallet: walletProvider,
pool: poolAddress,
owner: new PublicKey(address),
amountIn: new BN(1000000),
minimumAmountOut: quote?.minimumAmountOut || new BN(0),
swapBaseForQuote: false,
referralTokenAccount: null,
})
}

const handleWithdrawFees = async () => {
if (!walletProvider || !address) return

await withdraw.mutateAsync({
wallet: walletProvider,
pool: poolAddress,
owner: new PublicKey(address),
type: 'creatorTradingFee',
})
}

if (isLoading) return

`tsx
import { WalletProvider, ConnectionProvider } from '@solana/wallet-adapter-react'
import { WalletModalProvider } from '@solana/wallet-adapter-react-ui'
import { PhantomWalletAdapter, SolflareWalletAdapter } from '@solana/wallet-adapter-wallets'
import { DbcProvider } from '@notdotmarket/dbc-hooks'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { Connection } from '@solana/web3.js'

const queryClient = new QueryClient()
const connection = new Connection('https://api.devnet.solana.com')

const wallets = [
new PhantomWalletAdapter(),
new SolflareWalletAdapter(),
]

function App() {
return (











)
}

// Then use with useWallet hook
import { useWallet } from '@solana/wallet-adapter-react'

function TradingComponent() {
const wallet = useWallet()
const swap = useSwap()

const handleSwap = async () => {
if (!wallet.publicKey) return

await swap.mutateAsync({
wallet, // Pass wallet adapter directly
pool: poolAddress,
owner: wallet.publicKey,
// ...
})
}
}
`

Available Hooks

$3

#### Pool Information
- usePoolInfo(poolAddress) - Fetch pool and config data
- usePoolConfig(configAddress) - Fetch pool configuration
- usePools() - Fetch all pools
- usePoolsByConfig(configAddress) - Pools by config
- usePoolsByCreator(creatorAddress) - Pools by creator
- usePoolByBaseMint(mintAddress) - Pool by base token

#### Pool State & Metrics
- usePoolCurveProgress(poolAddress) - Bonding curve progress (0-1)
- usePoolMetadata(poolAddress) - Pool metadata
- usePoolExpiryDays(poolAddress) - Days remaining until curve expires (null if no expiry)
- usePoolStats(poolAddress) - Pool statistics (tokens sold, amount raised, percent sold)
- useTokensSold(poolAddress) - Number of tokens sold
- useAmountRaised(poolAddress) - Amount of quote tokens (SOL) raised
- usePoolMigrationQuoteThreshold(poolAddress) - Migration threshold

#### Pool Configurations
- usePoolConfigs() - All pool configurations
- usePoolConfigsByOwner(ownerAddress) - Configs by owner

#### Fee Information
- useFeeBreakdown(poolAddress) - Detailed fee breakdown
- usePoolFeeMetrics(poolAddress) - Current fee metrics
- usePoolsFeesByConfig(configAddress) - Fees for config pools
- usePoolsFeesByCreator(creatorAddress) - Fees for creator pools
- useSaleTax(params) - Check if sale tax is enabled and calculate tax amount

#### Partner & Migration
- usePartnerMetadata(partnerAddress) - Partner metadata
- useDammV1MigrationMetadata(poolAddress) - DAMM V1 migration data
- useDammV1LockEscrow(poolAddress) - DAMM V1 lock escrow

#### Token Information
- useTokenDetails(tokenMint, fetchMetadata?) - Comprehensive token details including metadata, decimals, supply, and logo

#### Trade Event Monitoring (Real-time)
- useTradeEventListener(params) - Listen for real-time trade events and store in Redis for charts
- useTradeHistory(params) - Fetch historical trade events from Redis

Note: Trade event monitoring requires backend API implementation. See TRADE_EVENT_LISTENER.md for setup guide.

#### Swap Quotes
- useSwapQuote(params) - Calculate swap quote (v1, exact input)
- useSwapQuote2(params) - Calculate swap quote (v2, multiple modes)

Note: Both swap quote hooks return a price field (number) which is the actual token price calculated from the sqrtPrice. This makes it easier to display human-readable prices without manual conversion.

$3

`typescript
enum SwapMode {
ExactIn = 0, // Specify exact input amount
PartialFill = 1, // Allow partial fills if liquidity insufficient
ExactOut = 2, // Specify exact output amount (calculates required input)
}
`

Example usage:

`tsx
// ExactIn: Specify how much to swap in
const { data } = useSwapQuote2({
poolAddress,
swapBaseForQuote: false,
swapMode: SwapMode.ExactIn,
amountIn: new BN(1000000),
slippageBps: 100,
})

// Access the actual price
if (data) {
console.log('Token Price:', data.price) // Human-readable price
console.log('Output Amount:', data.outputAmount.toString())
console.log('Trading Fee:', data.tradingFee.toString())
}

// ExactOut: Specify desired output
const { data } = useSwapQuote2({
poolAddress,
swapBaseForQuote: false,
swapMode: SwapMode.ExactOut,
amountOut: new BN(900000),
slippageBps: 100,
})
`

Withdrawal Types

`typescript
type WithdrawType =
| 'creatorSurplusQuote' // Creator withdraws surplus quote tokens
| 'partnerSurplusQuote' // Partner withdraws surplus quote tokens
| 'partnerSurplusBase' // Partner withdraws surplus base tokens (NoMigration pools)
| 'creatorTradingFee' // Creator withdraws trading fees
| 'partnerTradingFee' // Partner withdraws trading fees
`

Example usage:

`tsx
const { address } = useAppKitAccount()
const { walletProvider } = useAppKitProvider('solana')
const withdraw = useWithdraw()

await withdraw.mutateAsync({
wallet: walletProvider,
pool: poolAddress,
owner: new PublicKey(address),
type: 'creatorTradingFee',
})
`

Pool Expiry Tracking

Track when a bonding curve expires with usePoolExpiryDays:

`tsx
import { usePoolExpiryDays } from '@notdotmarket/dbc-hooks'

function PoolExpiryDisplay({ poolAddress }) {
const { data: daysLeft, isLoading } = usePoolExpiryDays(poolAddress)

if (isLoading) return

`tsx
import { useTokenDetails } from '@notdotmarket/dbc-hooks'
import { PublicKey } from '@solana/web3.js'

function TokenDisplay({ tokenMint }) {
// fetchMetadata=true (default) will also fetch the JSON metadata from URI
const { data: token, isLoading } = useTokenDetails(tokenMint, true)

if (isLoading) return

if (!token) return

Token not found

return (

{/ Token Logo /}
{token.metadata?.logo && (
src={token.metadata.logo}
alt={token.metadata.name}
className="token-logo"
/>
)}

{/ Token Identity /}

{token.metadata?.name || 'Unknown Token'}

{token.metadata?.symbol || 'N/A'}

{token.metadata?.description && (

{token.metadata.description}

)}

{/ Token Stats /}

Mint Address:

{token.mint.toString()}

Decimals:

{token.decimals}

Total Supply:

{(Number(token.supply) / Math.pow(10, token.decimals)).toLocaleString()}

Token Type:

{token.isToken2022 ? 'Token-2022' : 'SPL Token'}

Mint Authority:

{token.mintAuthority ? token.mintAuthority.toString() : 'Revoked ✓'}

Freeze Authority:

{token.freezeAuthority ? token.freezeAuthority.toString() : 'None'}

{/ Metadata URI /}
{token.metadata?.uri && (

Metadata:

View Metadata

)}

)
}

// Example: Fetch metadata but skip JSON fetch for faster loading
function QuickTokenInfo({ tokenMint }) {
const { data: token } = useTokenDetails(tokenMint, false)

return (

{token?.metadata?.symbol || 'Loading...'}

{token?.decimals} decimals

)
}

// Example: Display token in a pool interface
function PoolTokenInfo({ poolAddress }) {
const { data: poolInfo } = usePoolInfo(poolAddress)
const { data: baseToken } = useTokenDetails(poolInfo?.baseMint)
const { data: quoteToken } = useTokenDetails(poolInfo?.quoteMint)

return (

{baseToken?.metadata?.logo && (

)}
{baseToken?.metadata?.symbol}

/

{quoteToken?.metadata?.logo && (

)}
{quoteToken?.metadata?.symbol}

)
}

`typescript
interface TokenDetails {
mint: PublicKey // Token mint address
decimals: number // Number of decimals
supply: string // Total supply in smallest units
mintAuthority: PublicKey | null // Null if revoked (fixed supply)
freezeAuthority: PublicKey | null // Null if no freeze authority
metadata?: TokenMetadata // On-chain metadata (if exists)
isToken2022: boolean // True for Token-2022, false for SPL
}

interface TokenMetadata {
name: string // Token name from on-chain metadata
symbol: string // Token symbol from on-chain metadata
uri: string // Metadata JSON URI
logo?: string // Logo/image URL from JSON metadata
image?: string // Image URL from JSON metadata
description?: string // Description from JSON metadata
}
`

Pool Statistics (Tokens Sold & Amount Raised)

Track pool performance metrics:

`tsx
import { usePoolStats, useTokensSold, useAmountRaised } from '@notdotmarket/dbc-hooks'
import { LAMPORTS_PER_SOL } from '@solana/web3.js'

// Option 1: Get all stats at once (recommended)
function PoolStatsDisplay({ poolAddress }) {
const { data: stats, isLoading } = usePoolStats(poolAddress)

if (isLoading) return