SDK Reference

Deploy a new bond token

typescript
async deployBondkitToken(  config: BondkitTokenConfig): Promise<Address>

Parameters:

typescript
interface BondkitTokenConfig {  name: string;                      // Token name  symbol: string;                    // Token symbol  feeRecipient: Address;            // Receives trading fees  finalTokenSupply: bigint;         // Total supply (18 decimals)  aggressivenessFactor: number;     // 0-100 curve steepness  lpSplitRatioFeeRecipientBps: bigint; // LP fee share (basis points)  targetAmount: bigint;             // Migration target in trading token (18 decimals)  migrationAdminAddress: Address;   // Can trigger migration  bondingPhaseSplitter: Address;    // Bonding phase fee splitter  v4PoolManager: Address;           // Uniswap V4 pool manager  v4Hook: Address;                  // Custom Uniswap V4 hook  v4PoolFee: number;                // Pool fee tier (3000 = 0.3%)  v4TickSpacing: number;            // Tick spacing for the pool  tradingToken: Address;            // Token used for trading (B3/ETH/etc)}

Example:

typescript
const tokenAddress = await factory.deployBondkitToken({  name: "My Token",  symbol: "MTK",  feeRecipient: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",  finalTokenSupply: parseEther("1000000"),  aggressivenessFactor: 50,  lpSplitRatioFeeRecipientBps: 1000n, // 10%  targetAmount: parseEther("10"),  migrationAdminAddress: "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",  bondingPhaseSplitter: "0x2AB69e0d9D20D3700466153D84a6574128154Fd2",  v4PoolManager: "0x498581fF718922c3f8e6A244956aF099B2652b2b",  v4Hook: "0xB36f4A2FB18b745ef8eD31452781a463d2B3f0cC",  v4PoolFee: 3000,  v4TickSpacing: 60,  tradingToken: "0xB3B32F9f8827D4634fE7d973Fa1034Ec9fdDB3B3"});

Get all deployed tokens

typescript
async getDeployedBondkitTokens(): Promise<Address[]>

Returns: Array of token addresses

Example:

typescript
const tokens = await factory.getDeployedBondkitTokens();console.log(`Found ${tokens.length} tokens`);

Get token configuration

typescript
async getBondkitTokenConfig(  tokenAddress: Address): Promise<BondkitTokenConfig>

Example:

typescript
const config = await factory.getBondkitTokenConfig(  "0x123...");console.log(`Token name: ${config.name}`);

Get implementation contract

typescript
async getImplementationAddress(): Promise<Address>

Example:

typescript
const impl = await factory.getImplementationAddress();console.log(`Implementation: ${impl}`);

Connect wallet provider

typescript
connect(provider?: EIP1193Provider): boolean

Example:

typescript
// Browser environmentconst connected = factory.connect(window.ethereum);// Custom providerimport { custom } from "viem";const transport = custom(provider);factory.connect(transport);

typescript
// Basic token infoasync name(): Promise<string>async symbol(): Promise<string>async decimals(): Promise<number>async totalSupply(): Promise<bigint>// Balancesasync balanceOf(address: Address): Promise<bigint>async allowance(  owner: Address,   spender: Address): Promise<bigint>// Exampleconst balance = await token.balanceOf(userAddress);console.log(`Balance: ${formatEther(balance)}`);

typescript
// Current price per tokenasync getCurrentBondingCurvePricePerToken(): Promise<bigint>// Current price in trading tokenasync getCurrentPrice(): Promise<bigint>// Quote for buyingasync getAmountOfTokensToBuy(  tradingTokenAmount: bigint | string): Promise<bigint>// Quote for sellingasync getAmountOfTradingTokensToSell(  tokenAmount: bigint): Promise<bigint>// Bonding progressasync getBondingProgress(): Promise<{  progress: number;      // 0-1 (percentage)  raised: number;        // Amount raised (converted to number)  threshold: number;     // Target amount (converted to number)}>// Exampleconst progress = await token.getBondingProgress();console.log(`Progress: ${(progress.progress * 100).toFixed(2)}%`);

typescript
// Token stateasync getStatus(): Promise<TokenStatus>async isMigrated(): Promise<boolean>async canMigrate(): Promise<boolean>// Configurationasync getOwner(): Promise<Address>async getFeeRecipient(): Promise<Address>async getAggressivenessFactor(): Promise<number>async getTargetAmount(): Promise<bigint>// Migration infoasync getMigrationData(): Promise<{  ethForLp: bigint;  tokensForLp: bigint;  sqrtPriceX96: bigint;}>// Exampleif (await token.canMigrate()) {  console.log("Ready to migrate!");}

typescript
// Token holdersasync getPaginatedHolders(  offset: number,  limit: number): Promise<{  holders: Address[];  total: number;}>// Transaction history (from API)async getTransactionHistory(  options?: GetTransactionHistoryOptions): Promise<TransactionResponse>// Options interfaceinterface GetTransactionHistoryOptions {  userAddress?: Address;  type?: "buy" | "sell";  from?: number;        // Timestamp  to?: number;          // Timestamp  limit?: number;       // 1-100  offset?: number;}// Exampleconst history = await token.getTransactionHistory({  type: "buy",  limit: 10});

Methods for interacting with the trading token

typescript
// Get trading token address (B3/ETH/etc)async getTradingTokenAddress(): Promise<Address>// Get trading token symbol  async getTradingTokenSymbol(): Promise<string>// Get user's trading token balanceasync getTradingTokenBalanceOf(account: Address): Promise<bigint>// Check current token status/phaseasync currentStatus(): Promise<TokenStatus>async getCurrentPhase(): Promise<string>// Check if DEX swapping is availableasync isSwapAvailable(): Promise<boolean>

Example:

typescript
// Check what trading token is usedconst tradingTokenAddress = await token.getTradingTokenAddress();const tradingTokenSymbol = await token.getTradingTokenSymbol();console.log(`Trading with: ${tradingTokenSymbol} (${tradingTokenAddress})`);// Check user's trading token balanceconst tradingBalance = await token.getTradingTokenBalanceOf(userAddress);console.log(`Trading token balance: ${formatEther(tradingBalance)}`);// Check current phaseconst status = await token.currentStatus();if (status === TokenStatus.Dex) {  console.log("Token is in DEX trading phase");}

Built-in swap methods for DEX phase trading

typescript
// Get swap quotesasync getSwapQuoteForBondkitToken(  amountTradingTokenIn: string,  slippageTolerance?: number): Promise<SwapQuote | null>async getSwapQuoteForTradingToken(  amountBondkitTokenIn: string,   slippageTolerance?: number): Promise<SwapQuote | null>// Execute swapsasync swapTradingTokenForBondkitToken(  amountTradingTokenIn: string,  slippageTolerance?: number,  walletClient: WalletClient): Promise<string | null>async swapBondkitTokenForTradingToken(  amountBondkitTokenIn: string,  slippageTolerance?: number,   walletClient: WalletClient): Promise<string | null>

Example:

typescript
// Check if swapping is available (DEX phase only)const canSwap = await token.isSwapAvailable();if (!canSwap) {  console.log("Still in bonding phase - use buy()/sell()");  return;}// Get quote for trading 100 B3 tokens → bondkit tokensconst quote = await token.getSwapQuoteForBondkitToken(  "100",      // 100 trading tokens  0.005       // 0.5% slippage);if (quote) {  console.log(`Will receive: ${quote.amountOut} bondkit tokens`);  console.log(`Price impact: ${quote.priceImpact}%`);    // Execute the swap  const txHash = await token.swapTradingTokenForBondkitToken(    "100",    0.005,    walletClient  );  console.log(`Swap completed: ${txHash}`);}

Buy tokens with trading token

typescript
async buy(  amount: bigint | string,  minTokensOut: bigint): Promise<Hex>

Parameters:

• amount: Amount of trading token to spend (as string or bigint)
• minTokensOut: Minimum tokens to receive (slippage protection)

Example:

typescript
// Get quote firstconst quote = await token.getAmountOfTokensToBuy(  parseEther("100") // 100 trading tokens);// Buy with 5% slippage toleranceconst minTokens = quote * 95n / 100n;const txHash = await token.buy(  parseEther("100"), // amount: 100 trading tokens  minTokens          // minTokensOut: slippage protection);console.log(`Transaction: ${txHash}`);

Sell tokens for trading token

typescript
async sell(  tokenAmount: bigint,  minTradingTokenOut: bigint): Promise<Hex>

Parameters:

• tokenAmount: Amount of tokens to sell
• minTradingTokenOut: Minimum trading token to receive (slippage protection)

Example:

typescript
// Sell 1000 tokensconst sellAmount = parseEther("1000");// Get quoteconst quote = await token.getAmountOfTradingTokensToSell(sellAmount);// Sell with slippage protectionconst minTradingTokenOut = quote * 95n / 100n;const txHash = await token.sell(sellAmount, minTradingTokenOut);

Migrate to Uniswap v4

typescript
async migrateToDex(): Promise<Hex>

Requirements:

• Caller must be migration admin
• Target must be reached

Example:

typescript
if (await token.canMigrate()) {  const txHash = await token.migrateToDex();  console.log(`Migration tx: ${txHash}`);}

Transfer or renounce token ownership

typescript
// Transfer ownership to new addressasync transferTokenOwnership(  newOwner: Address): Promise<Hex>// Renounce ownership (irreversible)async renounceTokenOwnership(): Promise<Hex>

Example:

typescript
// Transfer ownership to multisigconst multisig = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1";await token.transferTokenOwnership(multisig);// Or renounce ownership completely (be careful!)await token.renounceTokenOwnership();

typescript
// Standard transfersasync transfer(  to: Address,  amount: bigint): Promise<Hex>async transferFrom(  from: Address,  to: Address,  amount: bigint): Promise<Hex>// Approvalsasync approve(  spender: Address,  amount: bigint): Promise<Hex>// Exampleawait token.approve(  spenderAddress,  parseEther("1000"));

Get swap price quote

typescript
async getSwapQuote(params: SwapParams): Promise<SwapQuote | null>

Parameters:

typescript
interface SwapParams {  tokenIn: Address;           // Token to sell  tokenOut: Address;          // Token to buy  amountIn: string;           // Amount to sell (human readable)  tokenInDecimals: number;    // Decimals of input token  tokenOutDecimals: number;   // Decimals of output token  slippageTolerance: number;  // Slippage tolerance (0.01 = 1%)  recipient: Address;         // Address to receive tokens  deadline?: number;          // Transaction deadline (timestamp)}

Returns:

typescript
interface SwapQuote {  amountOut: string;          // Expected output amount  amountOutMin: string;       // Minimum output (with slippage)  priceImpact: string;        // Price impact percentage  executionPrice: string;     // Execution price  fee: string;                // Swap fee}

Example:

typescript
// Get quote for swapping 100 B3 tokens for bondkit tokensconst quote = await swapService.getSwapQuote({  tokenIn: "0xB3B32F9f8827D4634fE7d973Fa1034Ec9fdDB3B3", // B3 token  tokenOut: bondkitTokenAddress,  amountIn: "100",  tokenInDecimals: 18,  tokenOutDecimals: 18,  slippageTolerance: 0.005, // 0.5%  recipient: userAddress});if (quote) {  console.log(`Will receive: ${quote.amountOut} tokens`);  console.log(`Price impact: ${quote.priceImpact}%`);}

Execute swap transaction

typescript
async executeSwap(params: SwapParams, walletClient: WalletClient): Promise<string | null>

Parameters:

• params: Same SwapParams as getSwapQuote
• walletClient: Connected wallet client

Example:

typescript
// First get a quoteconst quote = await swapService.getSwapQuote(swapParams);if (quote) {  // Execute the swap  const txHash = await swapService.executeSwap(    swapParams,    walletClient  );    console.log(`Swap executed: ${txHash}`);}

Built-in Support:

• Candlestick charts
• Volume indicators
• Price overlays
• Technical analysis tools
• Multiple timeframes (1m, 5m, 1h, 1D, etc.)

Customization:

• Light/dark themes
• Responsive design
• Mobile-friendly interface
• Professional trading UI

Automatic Data Feeds:

• Real-time price data from B3 API
• OHLCV (Open, High, Low, Close, Volume) data
• Historical price charts
• Transaction-based price updates

UDF Compatible:

• Standard TradingView datafeed format
• Configurable API endpoints
• Fallback configurations

Optimized Loading:

• TradingView library loaded from CDN
• Lazy loading with loading states
• Error handling and fallbacks
• Configurable CDN domains

Production Ready:

• Automatic CDN switching
• Custom domain support
• Development/production configurations