@b3dotfun/sdk 0.0.40 → 0.0.41

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 {
@@ -244,12 +245,19 @@ export function useAnyspendFlow({
   // Handle order completion
   useEffect(() => {
     if (oat?.data?.order.status === "executed") {
-      console.log("Order executed successfully");
-      // just get the payload.amount if available from custompayload
-      const amount = (oat.data.order.payload as { amount?: string })?.amount;
-      onTransactionSuccess?.(amount);
+      // get the actualDstAmount if available from custompayload
+      const amount = (oat.data.order.payload as { actualDstAmount?: string })?.actualDstAmount;
+      const formattedActualDstAmount = amount
+        ? formatTokenAmount(BigInt(amount), oat.data.order.metadata.dstToken.decimals)
+        : undefined;
+      onTransactionSuccess?.(formattedActualDstAmount);
     }
-  }, [oat?.data?.order.status, oat?.data?.order.payload, onTransactionSuccess]);
+  }, [
+    oat?.data?.order.status,
+    oat?.data?.order.payload,
+    onTransactionSuccess,
+    oat?.data?.order.metadata.dstToken.decimals,
+  ]);
 
   return {
     // State

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

@@ -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/chain.ts

@@ -149,7 +149,7 @@ export const EVM_MAINNET: Record<number, IEVMChain> = {
     name: bsc.name,
     logoUrl: "https://avatars.githubusercontent.com/u/45615063?s=280&v=4",
     type: ChainType.EVM,
-    nativeRequired: parseEther("0.000025"),
+    nativeRequired: parseEther("0.0001"),
     canDepositNative: true,
     defaultToken: getBnbToken(),
     nativeToken: getBnbToken(),

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/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";