@b3dotfun/sdk 0.0.40-alpha.1 → 0.0.40-alpha.11

package/dist/cjs/bondkit/bondkitToken.js

@@ -6,6 +6,8 @@ const accounts_1 = require("viem/accounts");
 const chains_1 = require("viem/chains");
 const abis_1 = require("./abis");
 const config_1 = require("./config");
+const swapService_1 = require("./swapService");
+const types_1 = require("./types");
 // Event ABI snippets for decoding
 const boughtEventAbi = abis_1.BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveBuy");
 const soldEventAbi = abis_1.BondkitTokenABI.find(item => item.type === "event" && item.name === "BondingCurveSell");
@@ -14,8 +16,8 @@ const dexMigrationEventAbi = abis_1.BondkitTokenABI.find(item => item.type === "
 const OKX_POLLING_MAX_RETRIES = 60; // 5 minutes with 5 second intervals
 const OKX_POLLING_INTERVAL_MS = 5000; // 5 seconds
 class BondkitToken {
-    constructor(contractAddress, walletKey) {
-        const sdkConfig = (0, config_1.getConfig)(chains_1.base.id);
+    constructor(contractAddress, walletKey, rpcUrl) {
+        const sdkConfig = (0, config_1.getConfig)(chains_1.base.id, rpcUrl);
         this.chain = sdkConfig.chain;
         this.rpcUrl = sdkConfig.rpcUrl;
         this.apiEndpoint = sdkConfig.apiEndpoint;
@@ -558,5 +560,269 @@ 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 swapService_1.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 === types_1.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 ? (0, accounts_1.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 ? (0, accounts_1.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 = (0, viem_1.getContract)({
+                address: tradingTokenAddress,
+                abi: viem_1.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 = (0, viem_1.getContract)({
+                address: tokenAddress,
+                abi: viem_1.erc20Abi,
+                client: this.publicClient,
+            });
+            const symbol = await tradingTokenContract.read.symbol();
+            return symbol;
+        }
+        catch (error) {
+            console.warn("Error fetching trading token symbol:", error);
+            return undefined;
+        }
+    }
 }
 exports.BondkitToken = BondkitToken;

package/dist/cjs/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/cjs/bondkit/bondkitTokenFactory.js

@@ -8,14 +8,14 @@ const config_1 = require("./config");
 // Define the event ABI snippet for BondkitTokenCreated specifically for decoding
 const bondkitTokenCreatedEventAbi = abis_1.BondkitTokenFactoryABI.find(item => item.type === "event" && item.name === "BondkitTokenCreated");
 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 = (0, config_1.getConfig)(chainId);
+        const config = (0, config_1.getConfig)(chainId, rpcUrl);
         this.chain = config.chain;
         this.contractAddress = config.factoryAddress;
         this.rpcUrl = config.rpcUrl;

package/dist/cjs/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/cjs/bondkit/config.js

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

package/dist/cjs/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/cjs/bondkit/constants.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseMainnetRpcUrl = exports.BaseBondkitTokenFactoryContractAddress = void 0;
+exports.B3TokenAddress = exports.Permit2Address = exports.QuoterAddress = exports.UniversalRouterAddress = exports.BaseMainnetRpcUrl = exports.BaseBondkitTokenFactoryContractAddress = void 0;
 exports.BaseBondkitTokenFactoryContractAddress = "0x5d641bbB206d4B5585eCCd919F36270200A9A2Ad";
 exports.BaseMainnetRpcUrl = "https://base-rpc.publicnode.com";
+// Uniswap V4 addresses on Base
+exports.UniversalRouterAddress = "0x6ff5693b99212da76ad316178a184ab56d299b43";
+exports.QuoterAddress = "0x0d5e0f971ed27fbff6c2837bf31316121532048d";
+exports.Permit2Address = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+exports.B3TokenAddress = "0xB3B32F9f8827D4634fE7d973Fa1034Ec9fdDB3B3";

package/dist/cjs/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/cjs/bondkit/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TradingView = void 0;
+exports.TradingView = exports.BondkitSwapService = void 0;
 // Core exports
 __exportStar(require("./bondkitToken"), exports);
 __exportStar(require("./bondkitTokenFactory"), exports);
@@ -28,6 +28,9 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./types"), exports);
 // ABIs
 __exportStar(require("./abis"), exports);
+// Swap functionality
+var swapService_1 = require("./swapService");
+Object.defineProperty(exports, "BondkitSwapService", { enumerable: true, get: function () { return swapService_1.BondkitSwapService; } });
 // Components
 var TradingView_1 = require("./components/TradingView");
 Object.defineProperty(exports, "TradingView", { enumerable: true, get: function () { return __importDefault(TradingView_1).default; } });

package/dist/cjs/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 {};