@b3dotfun/sdk 0.0.40-alpha.2 → 0.0.40-alpha.21

package/src/anyspend/react/components/common/PanelOnramp.tsx

@@ -1,5 +1,6 @@
 import { useCoinbaseOnrampOptions, useGeoOnrampOptions } from "@b3dotfun/sdk/anyspend/react";
 import { components } from "@b3dotfun/sdk/anyspend/types/api";
+import { GetQuoteResponse } from "@b3dotfun/sdk/anyspend/types/api_req_res";
 import { ALL_CHAINS } from "@b3dotfun/sdk/anyspend/utils/chain";
 import { Input, useGetGeo, useProfile } from "@b3dotfun/sdk/global-account/react";
 import { cn, formatUsername } from "@b3dotfun/sdk/shared/utils";
@@ -7,8 +8,10 @@ import { formatAddress } from "@b3dotfun/sdk/shared/utils/formatAddress";
 import { ChevronRight, Wallet } from "lucide-react";
 import { useRef } from "react";
 import { toast } from "sonner";
+import { useFeatureFlags } from "../../contexts/FeatureFlagsContext";
 import { FiatPaymentMethod } from "./FiatPaymentMethod";
 import { OrderTokenAmountFiat } from "./OrderTokenAmountFiat";
+import { PointsBadge } from "./PointsBadge";
 
 export function PanelOnramp({
   srcAmountOnRamp,
@@ -25,6 +28,8 @@ export function PanelOnramp({
   recipientSelectionPanelIndex,
   dstTokenSymbol,
   hideDstToken = false,
+  anyspendQuote,
+  onShowPointsDetail,
 }: {
   srcAmountOnRamp: string;
   setSrcAmountOnRamp: (amount: string) => void;
@@ -40,7 +45,10 @@ export function PanelOnramp({
   recipientSelectionPanelIndex: number;
   dstTokenSymbol?: string;
   hideDstToken?: boolean;
+  anyspendQuote?: GetQuoteResponse;
+  onShowPointsDetail?: () => void;
 }) {
+  const featureFlags = useFeatureFlags();
   // Get geo-based onramp options to access fee information
   const { stripeWeb2Support } = useGeoOnrampOptions(srcAmountOnRamp);
 
@@ -245,21 +253,26 @@ export function PanelOnramp({
 
         <div className="">
           <div className="flex items-center justify-between">
-            {(() => {
-              const currentPaymentMethod = selectedPaymentMethod || FiatPaymentMethod.NONE;
-              const fee = getFeeFromApi(currentPaymentMethod);
-
-              return (
-                <>
-                  <span className="text-as-tertiarry text-sm">
-                    {fee !== null ? `Total (included $${fee.toFixed(2)} fee)` : "Total"}
-                  </span>
-                  <span className="text-as-primary font-semibold">
-                    ${getTotalAmount(currentPaymentMethod).toFixed(2)}
-                  </span>
-                </>
-              );
-            })()}
+            <div className="flex items-center gap-2">
+              <span className="text-as-tertiarry text-sm">
+                {(() => {
+                  const fee = getFeeFromApi(selectedPaymentMethod || FiatPaymentMethod.NONE);
+                  return fee !== null ? `Total (included $${fee.toFixed(2)} fee)` : "Total";
+                })()}
+              </span>
+              {featureFlags.showPoints &&
+                anyspendQuote?.data?.pointsAmount &&
+                anyspendQuote?.data?.pointsAmount > 0 && (
+                  <PointsBadge
+                    pointsAmount={anyspendQuote.data.pointsAmount}
+                    pointsMultiplier={anyspendQuote.data.pointsMultiplier}
+                    onClick={() => onShowPointsDetail?.()}
+                  />
+                )}
+            </div>
+            <span className="text-as-primary font-semibold">
+              ${getTotalAmount(selectedPaymentMethod || FiatPaymentMethod.NONE).toFixed(2)}
+            </span>
           </div>
         </div>
       </div>

package/src/anyspend/react/components/common/PointsBadge.tsx

@@ -0,0 +1,20 @@
+interface PointsBadgeProps {
+  pointsAmount: number;
+  pointsMultiplier?: number;
+  onClick?: () => void;
+}
+
+export function PointsBadge({ pointsAmount, pointsMultiplier, onClick }: PointsBadgeProps) {
+  return (
+    <button
+      className="bg-as-brand hover:scale-102 active:scale-98 relative flex cursor-pointer items-center gap-1 rounded-lg px-2 py-1 transition-all"
+      onClick={onClick}
+    >
+      <div className="pointer-events-none absolute inset-0 h-full w-full rounded-lg border border-white/10 border-t-white/20 bg-gradient-to-b from-white/10 to-white/0" />
+      <span className="relative text-xs text-white">
+        +{pointsAmount.toLocaleString()} pts
+        {pointsMultiplier && pointsMultiplier > 1 && <span className="ml-1 opacity-80">({pointsMultiplier}x)</span>}
+      </span>
+    </button>
+  );
+}

package/src/anyspend/react/components/common/PointsDetailPanel.tsx

@@ -0,0 +1,55 @@
+import { Button, ShinyButton } from "@b3dotfun/sdk/global-account/react";
+import { cn } from "@b3dotfun/sdk/shared/utils/cn";
+import { ArrowDown } from "lucide-react";
+import Link from "next/link";
+
+interface PointsDetailPanelProps {
+  pointsAmount?: number;
+  onBack: () => void;
+}
+
+export function PointsDetailPanel({ pointsAmount = 0, onBack }: PointsDetailPanelProps) {
+  return (
+    <div className="mx-auto flex w-[460px] max-w-full flex-col items-center gap-4">
+      <div className="flex w-full items-center justify-between">
+        <Button
+          variant="ghost"
+          onClick={onBack}
+          className="text-as-primary/70 hover:text-as-primary flex items-center gap-2"
+        >
+          <ArrowDown className="h-4 w-4 rotate-90" />
+          Back
+        </Button>
+      </div>
+
+      <div className="flex flex-col items-center gap-4 text-center">
+        <h3 className="text-as-primary text-xl font-bold">Earn Points with Every Swap</h3>
+        <p className="text-as-primary/70 text-balance text-sm leading-relaxed">
+          You'll earn <span className="text-as-brand font-semibold">+{pointsAmount.toLocaleString()} points</span>{" "}
+          towards the{" "}
+          <Link href="https://anyspend.com/points" target="_blank" className="text-as-brand underline">
+            next AnySpend airdrop
+          </Link>{" "}
+          when you complete this transaction.
+        </p>
+        <div className="bg-as-surface-primary border-as-border-secondary mt-2 w-full rounded-lg border p-4 text-left">
+          <h4 className="text-as-primary mb-2 font-semibold">How it works:</h4>
+          <ul className="text-as-primary/70 space-y-1 text-sm">
+            <li>• Points are earned based on transaction volume</li>
+            <li>• Higher volume = more points</li>
+            <li>• Points contribute to future airdrops</li>
+            <li>• Keep swapping to maximize your rewards</li>
+          </ul>
+        </div>
+        <ShinyButton
+          accentColor={"hsl(var(--as-brand))"}
+          onClick={onBack}
+          className={cn("as-main-button !bg-as-brand relative w-full")}
+          textClassName={cn("text-white")}
+        >
+          Back to Swap
+        </ShinyButton>
+      </div>
+    </div>
+  );
+}

package/src/anyspend/react/contexts/FeatureFlagsContext.tsx

@@ -0,0 +1,34 @@
+"use client";
+
+import { createContext, useContext, ReactNode } from "react";
+
+export interface FeatureFlags {
+  showPoints?: boolean;
+}
+
+interface FeatureFlagsContextType {
+  featureFlags: FeatureFlags;
+}
+
+const FeatureFlagsContext = createContext<FeatureFlagsContextType | undefined>(undefined);
+
+interface FeatureFlagsProviderProps {
+  children: ReactNode;
+  featureFlags?: FeatureFlags;
+}
+
+const defaultFeatureFlags: FeatureFlags = {
+  showPoints: false,
+};
+
+export function FeatureFlagsProvider({ children, featureFlags = defaultFeatureFlags }: FeatureFlagsProviderProps) {
+  return <FeatureFlagsContext.Provider value={{ featureFlags }}>{children}</FeatureFlagsContext.Provider>;
+}
+
+export function useFeatureFlags(): FeatureFlags {
+  const context = useContext(FeatureFlagsContext);
+  if (!context) {
+    return defaultFeatureFlags;
+  }
+  return context.featureFlags;
+}

package/src/anyspend/react/hooks/useAnyspendFlow.ts

@@ -31,6 +31,7 @@ export enum PanelView {
   RECIPIENT_SELECTION,
   ORDER_DETAILS,
   LOADING,
+  POINTS_DETAIL,
 }
 
 interface UseAnyspendFlowProps {

package/src/anyspend/react/providers/AnyspendProvider.tsx

@@ -3,10 +3,12 @@
 import { TooltipProvider } from "@b3dotfun/sdk/global-account/react";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { ReactNode, useState } from "react";
+import { FeatureFlags, FeatureFlagsProvider } from "../contexts/FeatureFlagsContext";
 import { StripeRedirectHandler } from "./StripeRedirectHandler";
 
 interface AnyspendProviderProps {
   children: ReactNode;
+  featureFlags?: FeatureFlags;
 }
 
 const defaultQueryClientConfig = {
@@ -29,27 +31,30 @@ const defaultQueryClientConfig = {
  * - Safe to use at the application root
  * - Configures sensible defaults for query caching
  * - Handles Stripe payment redirects and modal state
+ * - Provides feature flags configuration
  *
  * @example
  * ```tsx
  * function App() {
  *   return (
- *     <AnyspendProvider>
+ *     <AnyspendProvider featureFlags={{ showPoints: true }}>
  *       <YourApp />
  *     </AnyspendProvider>
  *   );
  * }
  * ```
  */
-export const AnyspendProvider = function AnyspendProvider({ children }: AnyspendProviderProps) {
+export const AnyspendProvider = function AnyspendProvider({ children, featureFlags }: AnyspendProviderProps) {
   const [queryClient] = useState(() => new QueryClient(defaultQueryClientConfig));
 
   return (
     <QueryClientProvider client={queryClient}>
-      <TooltipProvider>
-        <StripeRedirectHandler />
-        {children}
-      </TooltipProvider>
+      <FeatureFlagsProvider featureFlags={featureFlags}>
+        <TooltipProvider>
+          <StripeRedirectHandler />
+          {children}
+        </TooltipProvider>
+      </FeatureFlagsProvider>
     </QueryClientProvider>
   );
 };

package/src/anyspend/react/providers/index.ts

@@ -1,2 +1,3 @@
 export * from "./AnyspendProvider";
 export * from "./StripeRedirectHandler";
+export { useFeatureFlags, type FeatureFlags } from "../contexts/FeatureFlagsContext";

package/src/anyspend/types/api.ts

@@ -509,7 +509,7 @@ export interface paths {
                  * @description Type of trade execution
                  * @enum {string}
                  */
-                tradeType: "EXACT_INPUT" | "EXPECTED_OUTPUT" | "EXACT_OUTPUT";
+                tradeType: "EXACT_INPUT" | "EXACT_OUTPUT";
                 /**
                  * @description Amount to quote
                  * @example 1000000000000000000
@@ -805,6 +805,16 @@ export interface paths {
                  * @example 0
                  */
                 userBalance?: string;
+                /**
+                 * @description Anyspend points that will be awarded for the order
+                 * @example 100
+                 */
+                pointsAmount?: number;
+                /**
+                 * @description Multiplier applied to points that will be awarded for the order
+                 * @example 1.5
+                 */
+                pointsMultiplier?: number;
               };
               /** @example 200 */
               statusCode: number;

package/src/anyspend/types/api_req_res.ts

@@ -1,16 +1,12 @@
 import { paths } from "./api";
 
-export type GetOrderAndTxsResponse =
-  paths["/orders/{orderId}"]["get"]["responses"]["200"]["content"]["application/json"];
+export type GetOrderAndTxsResponse = paths["/orders/{orderId}"]["get"]["responses"]["200"]["content"]["application/json"];
 export type GetQuoteRequest = paths["/orders/quote"]["post"]["requestBody"]["content"]["application/json"];
 export type GetQuoteResponse = paths["/orders/quote"]["post"]["responses"]["200"]["content"]["application/json"];
-export type GetCoinbaseOnrampOptionsResponse =
-  paths["/onramp/coinbase/options"]["get"]["responses"]["200"]["content"]["application/json"];
+
+export type GetCoinbaseOnrampOptionsResponse = paths["/onramp/coinbase/options"]["get"]["responses"]["200"]["content"]["application/json"];
 export type GetOrderHistoryResponse = paths["/orders"]["get"]["responses"]["200"]["content"]["application/json"];
-export type GetTokenListResponse =
-  paths["/chains/{chainId}/tokens"]["get"]["responses"]["200"]["content"]["application/json"];
+export type GetTokenListResponse = paths["/chains/{chainId}/tokens"]["get"]["responses"]["200"]["content"]["application/json"];
 export type CreateOrderResponse = paths["/orders"]["post"]["responses"]["200"]["content"]["application/json"];
-export type GetStripeSupportedResponse =
-  paths["/onramp/stripe/supported"]["get"]["responses"]["200"]["content"]["application/json"];
-export type GetStripeClientSecret =
-  paths["/stripe/clientSecret"]["get"]["responses"]["200"]["content"]["application/json"];
+export type GetStripeSupportedResponse = paths["/onramp/stripe/supported"]["get"]["responses"]["200"]["content"]["application/json"];
+export type GetStripeClientSecret = paths["/stripe/clientSecret"]["get"]["responses"]["200"]["content"]["application/json"];

package/src/anyspend/utils/orderPayload.ts

@@ -31,6 +31,7 @@ export const buildPayload = (orderType: components["schemas"]["Order"]["type"],
         return {
           contractAddress: normalizeAddress(nft.contractAddress),
           nftPrice: nft?.price || "",
+          tokenId: null,
           contractType: nft?.type,
         };
       } else {

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.
 }