@b3dotfun/sdk 0.0.40-alpha.5 → 0.0.40-alpha.7

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

package/dist/types/bondkit/types.d.ts

@@ -49,10 +49,9 @@ export type DexMigrationEventArgs = {
     ethForFeeRecipient: bigint;
 };
 export declare enum TokenStatus {
-    Inactive = 0,// Assuming mapping from ABI, verify actual enum values if specified elsewhere
-    BondingPhase = 1,
-    DexPhase = 2,
-    Migrated = 3
+    Uninitialized = 0,
+    Bonding = 1,
+    Dex = 2
 }
 export interface GetTransactionHistoryOptions {
     userAddress?: Address;
@@ -80,3 +79,10 @@ export interface TransactionResponse {
     skip: number;
     data: Transaction[];
 }
+export interface SwapQuote {
+    amountOut: string;
+    amountOutMin: string;
+    priceImpact: string;
+    executionPrice: string;
+    fee: string;
+}

package/dist/types/global-account/react/components/B3Provider/B3Provider.d.ts

@@ -1,12 +1,12 @@
 import { PermissionsConfig } from "@b3dotfun/sdk/global-account/types/permissions";
+import "@reservoir0x/relay-kit-ui/styles.css";
 import { Account } from "thirdweb/wallets";
 import { ClientType } from "../../../client-manager";
 import { B3ContextType } from "./types";
-import "@reservoir0x/relay-kit-ui/styles.css";
 /**
  * Main B3Provider component
  */
-export declare function B3Provider({ theme, children, accountOverride, environment, automaticallySetFirstEoa, simDuneApiKey, toaster, clientType, rpcUrls, }: {
+export declare function B3Provider({ theme, children, accountOverride, environment, automaticallySetFirstEoa, simDuneApiKey, toaster, clientType, rpcUrls, partnerId, }: {
     theme: "light" | "dark";
     children: React.ReactNode;
     accountOverride?: Account;
@@ -19,6 +19,7 @@ export declare function B3Provider({ theme, children, accountOverride, environme
     };
     clientType?: ClientType;
     rpcUrls?: Record<number, string>;
+    partnerId?: string;
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * Inner provider component that provides the actual B3Context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.0.40-alpha.5",
+  "version": "0.0.40-alpha.7",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",
@@ -241,8 +241,8 @@
     "@b3dotfun/basement-api": "0.0.11",
     "@feathersjs/authentication-client": "5.0.33",
     "@feathersjs/feathers": "5.0.33",
-    "@feathersjs/socketio-client": "5.0.33",
     "@feathersjs/rest-client": "5.0.33",
+    "@feathersjs/socketio-client": "5.0.33",
     "@feathersjs/typebox": "5.0.33",
     "@fingerprintjs/fingerprintjs-pro-react": "^2.7.0",
     "@hey-api/client-fetch": "0.8.3",
@@ -261,6 +261,7 @@
     "@solana/web3.js": "^1.98.2",
     "@stripe/react-stripe-js": "^3.7.0",
     "@stripe/stripe-js": "^7.3.1",
+    "@thirdweb-dev/wagmi-adapter": "^0.2.141",
     "@web3icons/react": "3.16.0",
     "big.js": "^7.0.1",
     "class-variance-authority": "0.7.0",
@@ -329,10 +330,10 @@
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
     "react-native-mmkv": "^3.2.0",
-    "thirdweb": "^5.105.20",
+    "thirdweb": "5.106.0",
     "three": "^0.175.0",
-    "wagmi": "^2.14.15",
-    "viem": "^2.28.1"
+    "viem": "^2.28.1",
+    "wagmi": "^2.14.15"
   },
   "peerDependenciesMeta": {
     "@react-three/postprocessing": {

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,6 +55,7 @@ export class BondkitToken {
   private walletClientInstance: WalletClient;
   private connectedProvider?: EIP1193Provider;
   private tradingToken?: Address;
+  private swapService?: BondkitSwapService;
 
   constructor(contractAddress: string, walletKey?: string, rpcUrl?: string) {
     const sdkConfig = getConfig(base.id, rpcUrl);
@@ -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/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";