@b3dotfun/sdk 0.0.40 → 0.0.41-alpha.0

package/src/bondkit/bondkitToken.ts

@@ -13,13 +13,15 @@ import { privateKeyToAccount } from "viem/accounts";
 import { base } from "viem/chains";
 import { BondkitTokenABI } from "./abis";
 import { getConfig } from "./config";
+import { BondkitSwapService } from "./swapService";
 import type {
   BondkitTokenInitializationConfig,
   GetTransactionHistoryOptions,
+  SwapQuote,
   TokenDetails,
-  TokenStatus,
   TransactionResponse,
 } from "./types";
+import { TokenStatus } from "./types";
 
 // Event ABI snippets for decoding
 const boughtEventAbi = BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveBuy");
@@ -53,9 +55,10 @@ export class BondkitToken {
   private walletClientInstance: WalletClient;
   private connectedProvider?: EIP1193Provider;
   private tradingToken?: Address;
+  private swapService?: BondkitSwapService;
 
-  constructor(contractAddress: string, walletKey?: string) {
-    const sdkConfig = getConfig(base.id);
+  constructor(contractAddress: string, walletKey?: string, rpcUrl?: string) {
+    const sdkConfig = getConfig(base.id, rpcUrl);
     this.chain = sdkConfig.chain;
     this.rpcUrl = sdkConfig.rpcUrl;
     this.apiEndpoint = sdkConfig.apiEndpoint;
@@ -657,6 +660,323 @@ export class BondkitToken {
     return this.executeWrite("renounceOwnership", [], options);
   }
 
+  // --- DEX Swap Methods ---
+
+  /**
+   * Get the swap service instance (lazy initialization)
+   */
+  private getSwapService(): BondkitSwapService {
+    if (!this.swapService) {
+      this.swapService = new BondkitSwapService(this.contractAddress);
+    }
+    return this.swapService;
+  }
+
+  /**
+   * Check if DEX swapping is available (token must be in Dex phase)
+   */
+  public async isSwapAvailable(): Promise<boolean | undefined> {
+    try {
+      const status = await this.currentStatus();
+      return status === TokenStatus.Dex;
+    } catch (error) {
+      console.warn("Error checking swap availability:", error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Get swap quote for trading token → bondkit token
+   */
+  public async getSwapQuoteForBondkitToken(
+    amountTradingTokenIn: string,
+    slippageTolerance = 0.5,
+  ): Promise<SwapQuote | undefined> {
+    try {
+      // Check if swapping is available
+      const swapAvailable = await this.isSwapAvailable();
+      if (!swapAvailable) {
+        console.warn("DEX swapping not available - token must be in Dex phase");
+        return undefined;
+      }
+
+      const tradingTokenAddress = await this.getTradingTokenAddress();
+      if (!tradingTokenAddress) {
+        console.warn("Trading token address not available");
+        return undefined;
+      }
+
+      // Get token details for decimals
+      const [tradingTokenDecimals, bondkitTokenDecimals] = await Promise.all([
+        this.getTradingTokenDecimals(tradingTokenAddress),
+        this.decimals(),
+      ]);
+
+      if (tradingTokenDecimals === undefined || bondkitTokenDecimals === undefined) {
+        console.warn("Unable to fetch token decimals");
+        return undefined;
+      }
+
+      const swapService = this.getSwapService();
+      const quote = await swapService.getSwapQuote({
+        tokenIn: tradingTokenAddress,
+        tokenOut: this.contractAddress,
+        amountIn: amountTradingTokenIn,
+        tokenInDecimals: tradingTokenDecimals,
+        tokenOutDecimals: bondkitTokenDecimals,
+        slippageTolerance,
+        recipient: this.walletClientInstance.account?.address || "0x0000000000000000000000000000000000000000",
+      });
+      return quote || undefined;
+    } catch (error) {
+      console.warn("Error getting swap quote for bondkit token:", error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Get swap quote for bondkit token → trading token
+   */
+  public async getSwapQuoteForTradingToken(
+    amountBondkitTokenIn: string,
+    slippageTolerance = 0.5,
+  ): Promise<SwapQuote | undefined> {
+    try {
+      // Check if swapping is available
+      const swapAvailable = await this.isSwapAvailable();
+      if (!swapAvailable) {
+        console.warn("DEX swapping not available - token must be in Dex phase");
+        return undefined;
+      }
+
+      const tradingTokenAddress = await this.getTradingTokenAddress();
+      if (!tradingTokenAddress) {
+        console.warn("Trading token address not available");
+        return undefined;
+      }
+
+      // Get token details for decimals
+      const [bondkitTokenDecimals, tradingTokenDecimals] = await Promise.all([
+        this.decimals(),
+        this.getTradingTokenDecimals(tradingTokenAddress),
+      ]);
+
+      if (bondkitTokenDecimals === undefined || tradingTokenDecimals === undefined) {
+        console.warn("Unable to fetch token decimals");
+        return undefined;
+      }
+
+      const swapService = this.getSwapService();
+      const quote = await swapService.getSwapQuote({
+        tokenIn: this.contractAddress,
+        tokenOut: tradingTokenAddress,
+        amountIn: amountBondkitTokenIn,
+        tokenInDecimals: bondkitTokenDecimals,
+        tokenOutDecimals: tradingTokenDecimals,
+        slippageTolerance,
+        recipient: this.walletClientInstance.account?.address || "0x0000000000000000000000000000000000000000",
+      });
+      return quote || undefined;
+    } catch (error) {
+      console.warn("Error getting swap quote for trading token:", error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Swap trading token for bondkit token
+   */
+  public async swapTradingTokenForBondkitToken(
+    amountTradingTokenIn: string,
+    slippageTolerance = 0.5,
+    options?: ExecuteWriteOptions,
+  ): Promise<Hex | undefined> {
+    try {
+      // Check if swapping is available
+      const swapAvailable = await this.isSwapAvailable();
+      if (!swapAvailable) {
+        console.warn("DEX swapping not available - token must be in Dex phase");
+        return undefined;
+      }
+
+      if (!this.walletClientInstance.account && !this.walletKey) {
+        console.warn("Wallet key not set or client not connected for swap operation");
+        return undefined;
+      }
+
+      const tradingTokenAddress = await this.getTradingTokenAddress();
+      if (!tradingTokenAddress) {
+        console.warn("Trading token address not available");
+        return undefined;
+      }
+
+      // Get token details for decimals
+      const [tradingTokenDecimals, bondkitTokenDecimals] = await Promise.all([
+        this.getTradingTokenDecimals(tradingTokenAddress),
+        this.decimals(),
+      ]);
+
+      if (tradingTokenDecimals === undefined || bondkitTokenDecimals === undefined) {
+        console.warn("Unable to fetch token decimals");
+        return undefined;
+      }
+
+      const recipient =
+        this.walletClientInstance.account?.address ||
+        (this.walletKey ? privateKeyToAccount(this.walletKey).address : undefined);
+
+      if (!recipient) {
+        console.warn("Unable to determine recipient address");
+        return undefined;
+      }
+
+      const swapService = this.getSwapService();
+      const txHash = await swapService.executeSwap(
+        {
+          tokenIn: tradingTokenAddress,
+          tokenOut: this.contractAddress,
+          amountIn: amountTradingTokenIn,
+          tokenInDecimals: tradingTokenDecimals,
+          tokenOutDecimals: bondkitTokenDecimals,
+          slippageTolerance,
+          recipient,
+          deadline: (options?.value ? Math.floor(Date.now() / 1000) : 0) + 3600,
+        },
+        this.walletClientInstance,
+      );
+
+      return txHash ? (txHash as Hex) : undefined;
+    } catch (error) {
+      console.warn("Error swapping trading token for bondkit token:", error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Swap bondkit token for trading token
+   */
+  public async swapBondkitTokenForTradingToken(
+    amountBondkitTokenIn: string,
+    slippageTolerance = 0.5,
+    options?: ExecuteWriteOptions,
+  ): Promise<Hex | undefined> {
+    try {
+      // Check if swapping is available
+      const swapAvailable = await this.isSwapAvailable();
+      if (!swapAvailable) {
+        console.warn("DEX swapping not available - token must be in Dex phase");
+        return undefined;
+      }
+
+      if (!this.walletClientInstance.account && !this.walletKey) {
+        console.warn("Wallet key not set or client not connected for swap operation");
+        return undefined;
+      }
+
+      const tradingTokenAddress = await this.getTradingTokenAddress();
+      if (!tradingTokenAddress) {
+        console.warn("Trading token address not available");
+        return undefined;
+      }
+
+      // Get token details for decimals
+      const [bondkitTokenDecimals, tradingTokenDecimals] = await Promise.all([
+        this.decimals(),
+        this.getTradingTokenDecimals(tradingTokenAddress),
+      ]);
+
+      if (bondkitTokenDecimals === undefined || tradingTokenDecimals === undefined) {
+        console.warn("Unable to fetch token decimals");
+        return undefined;
+      }
+
+      const recipient =
+        this.walletClientInstance.account?.address ||
+        (this.walletKey ? privateKeyToAccount(this.walletKey).address : undefined);
+
+      if (!recipient) {
+        console.warn("Unable to determine recipient address");
+        return undefined;
+      }
+
+      const swapService = this.getSwapService();
+      const txHash = await swapService.executeSwap(
+        {
+          tokenIn: this.contractAddress,
+          tokenOut: tradingTokenAddress,
+          amountIn: amountBondkitTokenIn,
+          tokenInDecimals: bondkitTokenDecimals,
+          tokenOutDecimals: tradingTokenDecimals,
+          slippageTolerance,
+          recipient,
+          deadline: (options?.value ? Math.floor(Date.now() / 1000) : 0) + 3600,
+        },
+        this.walletClientInstance,
+      );
+
+      return txHash ? (txHash as Hex) : undefined;
+    } catch (error) {
+      console.warn("Error swapping bondkit token for trading token:", error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Helper method to get trading token decimals
+   */
+  private async getTradingTokenDecimals(tradingTokenAddress: Address): Promise<number | undefined> {
+    try {
+      // ETH has 18 decimals
+      if (tradingTokenAddress === "0x0000000000000000000000000000000000000000") {
+        return 18;
+      }
+
+      // For ERC20 tokens, read decimals from contract
+      const tradingTokenContract = getContract({
+        address: tradingTokenAddress,
+        abi: erc20Abi,
+        client: this.publicClient,
+      });
+
+      const decimals = await tradingTokenContract.read.decimals();
+      return Number(decimals);
+    } catch (error) {
+      console.warn("Error fetching trading token decimals:", error);
+      return undefined;
+    }
+  }
+
+  /**
+   * Get trading token symbol
+   * @param tradingTokenAddress Optional trading token address to avoid fetching it again
+   */
+  public async getTradingTokenSymbol(tradingTokenAddress?: Address): Promise<string | undefined> {
+    try {
+      const tokenAddress = tradingTokenAddress || (await this.getTradingTokenAddress());
+      if (!tokenAddress) {
+        return undefined;
+      }
+
+      // ETH symbol
+      if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+        return "ETH";
+      }
+
+      // For ERC20 tokens, read symbol from contract
+      const tradingTokenContract = getContract({
+        address: tokenAddress,
+        abi: erc20Abi,
+        client: this.publicClient,
+      });
+
+      const symbol = await tradingTokenContract.read.symbol();
+      return symbol;
+    } catch (error) {
+      console.warn("Error fetching trading token symbol:", error);
+      return undefined;
+    }
+  }
+
   // TODO: Add other specific write methods from BondkitTokenABI.ts
   // e.g., setBondingCurve (if it exists and is external), updateArtistAddress, etc.
 }

package/src/bondkit/bondkitTokenFactory.ts

@@ -30,14 +30,14 @@ export class BondkitTokenFactory {
   private walletClientInstance: WalletClient; // Made non-optional, initialized in constructor
   private connectedProvider?: EIP1193Provider;
 
-  constructor(chainId: SupportedChainId, walletKey?: string) {
+  constructor(chainId: SupportedChainId, walletKey?: string, rpcUrl?: string) {
     if (walletKey && !walletKey.startsWith("0x")) {
       this.walletKey = `0x${walletKey}` as Hex;
     } else if (walletKey) {
       this.walletKey = walletKey as Hex;
     }
 
-    const config = getConfig(chainId);
+    const config = getConfig(chainId, rpcUrl);
     this.chain = config.chain;
     this.contractAddress = config.factoryAddress;
     this.rpcUrl = config.rpcUrl;

package/src/bondkit/components/TradingView.tsx

@@ -1,10 +1,10 @@
 "use client";
 
-import { loadScriptFromCDN } from "./utils/cdn-loader";
-import { formatNumberSmall } from "./utils/format";
 import { Loader2 } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
 import { TradingViewProps } from "./types";
+import { loadScriptFromCDN } from "./utils/cdn-loader";
+import { formatNumberSmall } from "./utils/format";
 
 // TypeScript types - these will be loaded from CDN at runtime
 type ChartingLibraryWidgetOptions = any;
@@ -24,8 +24,6 @@ const GifLoadingOverlay = ({ className }: { className?: string }) => (
 );
 
 const TradingView = ({ className, tokenAddress, tokenSymbol }: TradingViewProps) => {
-  const theme = "light";
-
   // Use token info for the current trade
   const currentTrade = {
     product_id: tokenAddress && tokenSymbol ? `${tokenSymbol}-${tokenAddress}` : "BONDKIT",
@@ -282,7 +280,7 @@ const TradingView = ({ className, tokenAddress, tokenSymbol }: TradingViewProps)
         tvWidgetRef.current = null;
       }
     };
-  }, [theme, librariesLoaded]);
+  }, [librariesLoaded, currentTrade?.product_id, tradingViewDefaultInterval, tradingViewTimezone]);
 
   useEffect(() => {
     if (

package/src/bondkit/config.ts

@@ -18,9 +18,12 @@ const baseMainnetConfig: Config = {
   apiEndpoint: "https://api.b3.fun/bondkit-tokens",
 };
 
-export const getConfig = (chainId: number): Config => {
+export const getConfig = (chainId: number, rpcUrl?: string): Config => {
   if (chainId === base.id) {
-    return baseMainnetConfig;
+    return {
+      ...baseMainnetConfig,
+      rpcUrl: rpcUrl || BaseMainnetRpcUrl,
+    };
   }
   throw new Error(`Unsupported chainId: ${chainId}. This SDK is configured for Base (Chain ID: ${base.id}) only.`);
 };

package/src/bondkit/constants.ts

@@ -3,3 +3,10 @@ import type { Address } from "viem";
 export const BaseBondkitTokenFactoryContractAddress: Address = "0x5d641bbB206d4B5585eCCd919F36270200A9A2Ad";
 
 export const BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";
+
+// Uniswap V4 addresses on Base
+export const UniversalRouterAddress: Address = "0x6ff5693b99212da76ad316178a184ab56d299b43";
+export const QuoterAddress: Address = "0x0d5e0f971ed27fbff6c2837bf31316121532048d";
+export const Permit2Address: Address = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+
+export const B3TokenAddress: Address = "0xB3B32F9f8827D4634fE7d973Fa1034Ec9fdDB3B3";

package/src/bondkit/index.ts

@@ -12,5 +12,8 @@ export * from "./types";
 // ABIs
 export * from "./abis";
 
+// Swap functionality
+export { BondkitSwapService } from "./swapService";
+
 // Components
 export { default as TradingView } from "./components/TradingView";