@b3dotfun/sdk 0.0.40 → 0.0.41-alpha.0

package/dist/esm/bondkit/bondkitToken.js

@@ -3,6 +3,8 @@ import { privateKeyToAccount } from "viem/accounts";
 import { base } from "viem/chains";
 import { BondkitTokenABI } from "./abis/index.js";
 import { getConfig } from "./config.js";
+import { BondkitSwapService } from "./swapService.js";
+import { TokenStatus } from "./types.js";
 // Event ABI snippets for decoding
 const boughtEventAbi = BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveBuy");
 const soldEventAbi = BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveSell");
@@ -11,8 +13,8 @@ const dexMigrationEventAbi = BondkitTokenABI.find(item => item.type === "event"
 const OKX_POLLING_MAX_RETRIES = 60; // 5 minutes with 5 second intervals
 const OKX_POLLING_INTERVAL_MS = 5000; // 5 seconds
 export class BondkitToken {
-    constructor(contractAddress, walletKey) {
-        const sdkConfig = getConfig(base.id);
+    constructor(contractAddress, walletKey, rpcUrl) {
+        const sdkConfig = getConfig(base.id, rpcUrl);
         this.chain = sdkConfig.chain;
         this.rpcUrl = sdkConfig.rpcUrl;
         this.apiEndpoint = sdkConfig.apiEndpoint;
@@ -555,4 +557,268 @@ export class BondkitToken {
     async renounceTokenOwnership(options) {
         return this.executeWrite("renounceOwnership", [], options);
     }
+    // --- DEX Swap Methods ---
+    /**
+     * Get the swap service instance (lazy initialization)
+     */
+    getSwapService() {
+        if (!this.swapService) {
+            this.swapService = new BondkitSwapService(this.contractAddress);
+        }
+        return this.swapService;
+    }
+    /**
+     * Check if DEX swapping is available (token must be in Dex phase)
+     */
+    async isSwapAvailable() {
+        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
+     */
+    async getSwapQuoteForBondkitToken(amountTradingTokenIn, slippageTolerance = 0.5) {
+        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
+     */
+    async getSwapQuoteForTradingToken(amountBondkitTokenIn, slippageTolerance = 0.5) {
+        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
+     */
+    async swapTradingTokenForBondkitToken(amountTradingTokenIn, slippageTolerance = 0.5, options) {
+        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 : undefined;
+        }
+        catch (error) {
+            console.warn("Error swapping trading token for bondkit token:", error);
+            return undefined;
+        }
+    }
+    /**
+     * Swap bondkit token for trading token
+     */
+    async swapBondkitTokenForTradingToken(amountBondkitTokenIn, slippageTolerance = 0.5, options) {
+        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 : undefined;
+        }
+        catch (error) {
+            console.warn("Error swapping bondkit token for trading token:", error);
+            return undefined;
+        }
+    }
+    /**
+     * Helper method to get trading token decimals
+     */
+    async getTradingTokenDecimals(tradingTokenAddress) {
+        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
+     */
+    async getTradingTokenSymbol(tradingTokenAddress) {
+        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;
+        }
+    }
 }

package/dist/esm/bondkit/bondkitTokenFactory.d.ts

@@ -10,7 +10,7 @@ export declare class BondkitTokenFactory {
     private rpcUrl;
     private walletClientInstance;
     private connectedProvider?;
-    constructor(chainId: SupportedChainId, walletKey?: string);
+    constructor(chainId: SupportedChainId, walletKey?: string, rpcUrl?: string);
     connect(provider?: EIP1193Provider): boolean;
     /**
      * Connects using an EIP-1193 provider and requests accounts, selecting the first one.

package/dist/esm/bondkit/bondkitTokenFactory.js

@@ -5,14 +5,14 @@ import { getConfig } from "./config.js";
 // Define the event ABI snippet for BondkitTokenCreated specifically for decoding
 const bondkitTokenCreatedEventAbi = BondkitTokenFactoryABI.find(item => item.type === "event" && item.name === "BondkitTokenCreated");
 export class BondkitTokenFactory {
-    constructor(chainId, walletKey) {
+    constructor(chainId, walletKey, rpcUrl) {
         if (walletKey && !walletKey.startsWith("0x")) {
             this.walletKey = `0x${walletKey}`;
         }
         else if (walletKey) {
             this.walletKey = walletKey;
         }
-        const config = getConfig(chainId);
+        const config = getConfig(chainId, rpcUrl);
         this.chain = config.chain;
         this.contractAddress = config.factoryAddress;
         this.rpcUrl = config.rpcUrl;

package/dist/esm/bondkit/components/TradingView.js

@@ -1,15 +1,14 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { loadScriptFromCDN } from "./utils/cdn-loader.js";
-import { formatNumberSmall } from "./utils/format.js";
 import { Loader2 } from "lucide-react";
 import { useEffect, useRef, useState } from "react";
+import { loadScriptFromCDN } from "./utils/cdn-loader.js";
+import { formatNumberSmall } from "./utils/format.js";
 // TradingView will be available on window after loading from CDN
 // Datafeed will be implemented inline
 // Mock loading overlay - replace with your actual loading component
 const GifLoadingOverlay = ({ className }) => (_jsx("div", { className: `absolute inset-0 flex items-center justify-center bg-white/50 backdrop-blur-sm ${className || ""}`, children: _jsx(Loader2, { className: "text-secondary-grey h-8 w-8 animate-spin" }) }));
 const TradingView = ({ className, tokenAddress, tokenSymbol }) => {
-    const theme = "light";
     // Use token info for the current trade
     const currentTrade = {
         product_id: tokenAddress && tokenSymbol ? `${tokenSymbol}-${tokenAddress}` : "BONDKIT",
@@ -245,7 +244,7 @@ const TradingView = ({ className, tokenAddress, tokenSymbol }) => {
                 tvWidgetRef.current = null;
             }
         };
-    }, [theme, librariesLoaded]);
+    }, [librariesLoaded, currentTrade?.product_id, tradingViewDefaultInterval, tradingViewTimezone]);
     useEffect(() => {
         if (chartLoaded &&
             currentTrade?.product_id &&

package/dist/esm/bondkit/config.d.ts

@@ -7,4 +7,4 @@ export interface Config {
     apiEndpoint: string;
 }
 export type SupportedChainId = typeof base.id;
-export declare const getConfig: (chainId: number) => Config;
+export declare const getConfig: (chainId: number, rpcUrl?: string) => Config;

package/dist/esm/bondkit/config.js

@@ -6,9 +6,12 @@ const baseMainnetConfig = {
     factoryAddress: BaseBondkitTokenFactoryContractAddress,
     apiEndpoint: "https://api.b3.fun/bondkit-tokens",
 };
-export const getConfig = (chainId) => {
+export const getConfig = (chainId, rpcUrl) => {
     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/dist/esm/bondkit/constants.d.ts

@@ -1,3 +1,7 @@
 import type { Address } from "viem";
 export declare const BaseBondkitTokenFactoryContractAddress: Address;
 export declare const BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";
+export declare const UniversalRouterAddress: Address;
+export declare const QuoterAddress: Address;
+export declare const Permit2Address: Address;
+export declare const B3TokenAddress: Address;

package/dist/esm/bondkit/constants.js

@@ -1,2 +1,7 @@
 export const BaseBondkitTokenFactoryContractAddress = "0x5d641bbB206d4B5585eCCd919F36270200A9A2Ad";
 export const BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";
+// Uniswap V4 addresses on Base
+export const UniversalRouterAddress = "0x6ff5693b99212da76ad316178a184ab56d299b43";
+export const QuoterAddress = "0x0d5e0f971ed27fbff6c2837bf31316121532048d";
+export const Permit2Address = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+export const B3TokenAddress = "0xB3B32F9f8827D4634fE7d973Fa1034Ec9fdDB3B3";

package/dist/esm/bondkit/index.d.ts

@@ -4,4 +4,5 @@ export * from "./config";
 export * from "./constants";
 export * from "./types";
 export * from "./abis";
+export { BondkitSwapService } from "./swapService";
 export { default as TradingView } from "./components/TradingView";

package/dist/esm/bondkit/index.js

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

package/dist/esm/bondkit/swapService.d.ts

@@ -0,0 +1,43 @@
+import type { Address, WalletClient } from "viem";
+import type { SwapQuote } from "./types";
+interface SwapParams {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    tokenInDecimals: number;
+    tokenOutDecimals: number;
+    slippageTolerance: number;
+    recipient: Address;
+    deadline?: number;
+}
+/**
+ * Internal swap service for handling Uniswap V4 swaps between trading token and bondkit token
+ */
+export declare class BondkitSwapService {
+    private v4Config;
+    private configInitialized;
+    private readonly bondkitTokenAddress;
+    private readonly publicClient;
+    constructor(bondkitTokenAddress: Address);
+    /**
+     * Initialize V4 pool configuration from bondkit token contract
+     */
+    private initializeV4Config;
+    /**
+     * Get V4 pool configuration
+     */
+    private getV4Config;
+    /**
+     * Handle token approvals for swap
+     */
+    private handleTokenApprovals;
+    /**
+     * Get swap quote
+     */
+    getSwapQuote(params: SwapParams): Promise<SwapQuote | null>;
+    /**
+     * Execute swap transaction
+     */
+    executeSwap(params: SwapParams, walletClient: WalletClient): Promise<string | null>;
+}
+export {};