@b3dotfun/sdk 0.0.1-alpha.1

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

@@ -0,0 +1,131 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { Nft, OnrampVendor, OrderType, Token, Tournament } from "@b3dotfun/sdk/anyspend/types";
+import { normalizeAddress, buildMetadata, buildPayload } from "@b3dotfun/sdk/anyspend/utils";
+import { useMutation } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { parseUnits } from "viem";
+import { base } from "viem/chains";
+import { USDC_BASE } from "@b3dotfun/sdk/anyspend/constants";
+
+export type OnrampOptions = {
+  vendor: OnrampVendor;
+  paymentMethod: string;
+  country: string;
+  redirectUrl: string;
+  ipAddress?: string; // Required for Stripe
+};
+
+export type CreateOnrampOrderParams = {
+  isMainnet: boolean;
+  recipientAddress: string;
+  orderType: OrderType;
+  dstChain: number;
+  dstToken: Token;
+  srcFiatAmount: string;
+  onramp: OnrampOptions;
+  expectedDstAmount: string;
+  creatorAddress?: string;
+  nft?: Nft & { price: string };
+  tournament?: Tournament & { contractAddress: string; entryPriceOrFundAmount: string };
+  payload?: any;
+};
+
+export type UseAnyspendCreateOnrampOrderProps = {
+  onSuccess?: (data: any) => void;
+  onError?: (error: Error) => void;
+};
+
+/**
+ * Hook for creating onramp orders in the Anyspend protocol
+ * Specifically handles orders that involve fiat-to-crypto onramp functionality
+ */
+export function useAnyspendCreateOnrampOrder({ onSuccess, onError }: UseAnyspendCreateOnrampOrderProps = {}) {
+  const { mutate: createOrder, isPending } = useMutation({
+    mutationFn: async (params: CreateOnrampOrderParams) => {
+      const {
+        isMainnet,
+        recipientAddress,
+        orderType,
+        dstChain,
+        dstToken,
+        srcFiatAmount,
+        onramp,
+        creatorAddress,
+        expectedDstAmount,
+        nft,
+        tournament,
+        payload
+      } = params;
+
+      try {
+        // Validate Stripe onramp options
+        if (onramp.vendor === "stripe" && !onramp.ipAddress) {
+          throw new Error("IP address is required for Stripe onramp");
+        }
+
+        // Validate required onramp fields
+        if (!onramp.vendor || !onramp.country) {
+          throw new Error("Missing required onramp fields: vendor, country");
+        }
+
+        const srcToken = USDC_BASE;
+        const srcChain = base.id;
+
+        // Create order with USDC on Base as source
+        const srcAmountOnRampInWei = parseUnits(srcFiatAmount, USDC_BASE.decimals);
+
+        return await anyspendService.createOrder({
+          isMainnet,
+          recipientAddress: normalizeAddress(recipientAddress),
+          type: orderType,
+          srcChain,
+          srcTokenAddress: normalizeAddress(srcToken.address),
+          dstChain,
+          dstTokenAddress: normalizeAddress(dstToken.address),
+          srcAmount: srcAmountOnRampInWei.toString(),
+          payload: buildPayload(orderType, {
+            orderType,
+            srcToken,
+            dstToken,
+            expectedDstAmount,
+            nft,
+            tournament,
+            payload
+          }),
+          onramp,
+          metadata: buildMetadata(orderType, {
+            orderType,
+            srcToken,
+            dstToken,
+            expectedDstAmount,
+            nft,
+            tournament,
+            payload
+          }),
+          creatorAddress: creatorAddress ? normalizeAddress(creatorAddress) : undefined
+        });
+      } catch (error: any) {
+        // If the error has a response with message and statusCode, throw that
+        if (error?.data) {
+          throw error.data;
+        }
+        // Otherwise throw the original error
+        throw error;
+      }
+    },
+    onSuccess: (data: any) => {
+      onSuccess?.(data);
+    },
+    onError: (error: Error) => {
+      onError?.(error);
+    }
+  });
+
+  return useMemo(
+    () => ({
+      createOrder,
+      isCreatingOrder: isPending
+    }),
+    [createOrder, isPending]
+  );
+}

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

@@ -0,0 +1,102 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { Nft, OrderType, Token, Tournament } from "@b3dotfun/sdk/anyspend/types";
+import { normalizeAddress, buildMetadata, buildPayload } from "@b3dotfun/sdk/anyspend/utils";
+import { useMutation } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+export type CreateOrderParams = {
+  isMainnet: boolean;
+  recipientAddress: string;
+  orderType: OrderType;
+  srcChain: number;
+  dstChain: number;
+  srcToken: Token;
+  dstToken: Token;
+  srcAmount: string;
+  expectedDstAmount?: string;
+  nft?: Nft & { price: string };
+  tournament?: Tournament & { contractAddress: string; entryPriceOrFundAmount: string };
+  creatorAddress?: string;
+  payload?: any;
+};
+
+export type UseAnyspendCreateOrderProps = {
+  onSuccess?: (data: any) => void;
+  onError?: (error: Error) => void;
+};
+
+/**
+ * Hook for creating orders in the Anyspend protocol
+ * Handles regular order creation for swaps, NFT minting, tournament participation, etc.
+ * For onramp orders, use useAnyspendCreateOnrampOrder instead.
+ */
+export function useAnyspendCreateOrder({ onSuccess, onError }: UseAnyspendCreateOrderProps = {}) {
+  const { mutate: createOrder, isPending } = useMutation({
+    mutationFn: async (params: CreateOrderParams) => {
+      const {
+        isMainnet,
+        recipientAddress,
+        orderType,
+        srcChain,
+        dstChain,
+        srcToken,
+        dstToken,
+        srcAmount,
+        creatorAddress
+      } = params;
+
+      try {
+        return await anyspendService.createOrder({
+          isMainnet,
+          recipientAddress: normalizeAddress(recipientAddress),
+          type: orderType,
+          srcChain,
+          dstChain,
+          srcTokenAddress: normalizeAddress(srcToken.address),
+          dstTokenAddress: normalizeAddress(dstToken.address),
+          srcAmount: srcAmount,
+          payload: buildPayload(orderType, {
+            orderType,
+            srcToken,
+            dstToken,
+            expectedDstAmount: params.expectedDstAmount,
+            nft: params.nft,
+            tournament: params.tournament,
+            payload: params.payload
+          }),
+          metadata: buildMetadata(orderType, {
+            orderType,
+            srcToken,
+            dstToken,
+            expectedDstAmount: params.expectedDstAmount,
+            nft: params.nft,
+            tournament: params.tournament,
+            payload: params.payload
+          }),
+          creatorAddress: creatorAddress ? normalizeAddress(creatorAddress) : undefined
+        });
+      } catch (error: any) {
+        // If the error has a response with message and statusCode, throw that
+        if (error?.data) {
+          throw error.data;
+        }
+        // Otherwise throw the original error
+        throw error;
+      }
+    },
+    onSuccess: (data: any) => {
+      onSuccess?.(data);
+    },
+    onError: (error: Error) => {
+      onError?.(error);
+    }
+  });
+
+  return useMemo(
+    () => ({
+      createOrder,
+      isCreatingOrder: isPending
+    }),
+    [createOrder, isPending]
+  );
+}

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

@@ -0,0 +1,36 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { GetOrderAndTxsResponse } from "@b3dotfun/sdk/anyspend/types";
+import { useQuery } from "@tanstack/react-query";
+import isEqual from "lodash/isEqual.js";
+import { useCallback, useMemo } from "react";
+
+// Hook to fetch and auto-refresh order status and transaction details
+export function useAnyspendOrderAndTransactions(isMainnet: boolean, orderId: string | undefined) {
+  const selectFn = useCallback((data: any) => {
+    if (!data) return undefined;
+    return data;
+  }, []);
+
+  const { data, isLoading, refetch, error } = useQuery<GetOrderAndTxsResponse>({
+    queryKey: ["getAnyspendOrderAndTransactions", orderId],
+    queryFn: () => anyspendService.getOrderAndTransactions(isMainnet, orderId),
+    enabled: Boolean(orderId),
+    refetchInterval: 3000,
+    staleTime: 1000,
+    select: selectFn,
+    structuralSharing: (oldData, newData) => {
+      if (isEqual(oldData, newData)) return oldData;
+      return newData;
+    }
+  });
+
+  return useMemo(
+    () => ({
+      orderAndTransactions: data,
+      isLoadingOrderAndTransactions: isLoading,
+      getOrderAndTransactionsError: error,
+      refetchOrderAndTransactions: refetch
+    }),
+    [data, error, isLoading, refetch]
+  );
+}

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

@@ -0,0 +1,29 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { useQuery } from "@tanstack/react-query";
+
+export function useAnyspendOrderHistory(
+  isMainnet: boolean,
+  creatorAddress: string | undefined,
+  limit: number = 100,
+  offset: number = 0
+) {
+  const {
+    data: rawData = [],
+    isLoading,
+    refetch,
+    error
+  } = useQuery({
+    queryKey: ["getOrderHistory", creatorAddress, limit, offset],
+    queryFn: async () => {
+      const response = await anyspendService.getOrderHistory(isMainnet, creatorAddress, limit, offset);
+      return response.data;
+    }
+  });
+
+  return {
+    orderHistory: rawData,
+    isLoadingOrderHistory: isLoading,
+    getOrderHistoryError: error,
+    refetchOrderHistory: refetch
+  };
+}

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

@@ -0,0 +1,58 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { GetQuoteRequest, OrderType } from "@b3dotfun/sdk/anyspend/types";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+/**
+ * React hook to fetch the price or rate for a relay swap using Anyspend.
+ *
+ * @param {boolean} isMainnet - Whether to use mainnet or testnet endpoints.
+ * @param {object} req - The request object containing source/destination chain, token addresses, and amount/price.
+ *                       (Consider specifying the exact type of 'req' if available, e.g., @param {AnyspendQuoteRequest} req)
+ * @param {boolean} [isRefetch=false] - If true, refetches the price every 10 seconds; otherwise, fetches once. Defaults to false.
+ *
+ * @returns {object} An object containing the state and data for the Anyspend quote.
+ * @property {object | undefined} anyspendQuote - The fetched quote data. (Consider specifying the exact type if available, e.g., AnyspendQuoteResponse)
+ * @property {boolean} isLoadingAnyspendQuote - Loading state for the quote query.
+ * @property {Error | null} getAnyspendQuoteError - Error object if the query failed, otherwise null.
+ * @property {Function} refetchAnyspendQuote - Function to manually refetch the quote.
+ *
+ * @remarks The query is enabled only if all required fields in `req` are present and the amount/price is non-zero.
+ */
+export function useAnyspendQuote(isMainnet: boolean, req: GetQuoteRequest) {
+  const { data, isLoading, refetch, error } = useQuery({
+    queryKey: ["useAnyspendQuote", isMainnet, req],
+    queryFn: () => {
+      return anyspendService.getQuote(isMainnet, req);
+    },
+    enabled: Boolean(
+      req.srcChain &&
+        req.dstChain &&
+        req.srcTokenAddress &&
+        req.dstTokenAddress &&
+        BigInt(
+          req.type === OrderType.Swap
+            ? req.amount
+            : req.type === OrderType.MintNFT
+              ? req.price
+              : req.type === OrderType.JoinTournament
+                ? req.price
+                : req.type === OrderType.FundTournament
+                  ? req.fundAmount
+                  : req.payload.amount
+        ) !== BigInt(0)
+    ),
+    refetchInterval: 10000,
+    retry: false
+  });
+
+  return useMemo(
+    () => ({
+      anyspendQuote: data,
+      isLoadingAnyspendQuote: isLoading,
+      getAnyspendQuoteError: error,
+      refetchAnyspendQuote: refetch
+    }),
+    [data, error, isLoading, refetch]
+  );
+}

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

@@ -0,0 +1,38 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { SendPermitDataRequestBody } from "@b3dotfun/sdk/anyspend/types";
+import { useMutation } from "@tanstack/react-query";
+import { UseAnyspendCreateOrderProps } from "./useAnyspendCreateOrder";
+
+export function useAnyspendSendPermitData({ onSuccess, onError }: UseAnyspendCreateOrderProps = {}) {
+  const { mutate: sendPermitData, isPending } = useMutation({
+    mutationFn: async ({ isMainnet, orderId, permitData }: SendPermitDataRequestBody & { isMainnet: boolean }) => {
+      try {
+        const response = await anyspendService.sendPermitData({
+          isMainnet,
+          orderId,
+          permitData
+        });
+        if (response.statusCode !== 200) throw response;
+        return response;
+      } catch (error: any) {
+        // If the error has a response with message and statusCode, throw that
+        if (error.response?.data) {
+          throw error.response.data;
+        }
+        // Otherwise throw the original error
+        throw error;
+      }
+    },
+    onSuccess: data => {
+      onSuccess?.(data);
+    },
+    onError: (error: Error) => {
+      onError?.(error);
+    }
+  });
+
+  return {
+    sendPermitData,
+    isSendingPermitData: isPending
+  };
+}

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

@@ -0,0 +1,24 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+export function useAnyspendTokenList(isMainnet: boolean, chainId: number, query: string) {
+  const {
+    data = [],
+    isLoading,
+    refetch
+  } = useQuery({
+    queryKey: ["getAnyspendTokenList", chainId, query],
+    queryFn: () => anyspendService.getTokenList(isMainnet, chainId, query),
+    enabled: true
+  });
+
+  return useMemo(
+    () => ({
+      data,
+      isLoading,
+      refetch
+    }),
+    [data, isLoading, refetch]
+  );
+}

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

@@ -0,0 +1,21 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+export function useCoinbaseOnrampOptions(isMainnet: boolean, country?: string) {
+  const { data, isLoading, error, refetch } = useQuery({
+    queryKey: ["getCoinbaseOnrampOptions", isMainnet, country],
+    queryFn: () => anyspendService.getCoinbaseOnrampOptions(isMainnet, country!),
+    enabled: Boolean(country)
+  });
+
+  return useMemo(
+    () => ({
+      coinbaseOnrampOptions: data,
+      isLoadingCoinbaseOnrampOptions: isLoading,
+      coinbaseOnrampOptionsError: error,
+      refetchCoinbaseOnrampOptions: refetch
+    }),
+    [data, isLoading, error, refetch]
+  );
+}

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

@@ -0,0 +1,58 @@
+import { useMemo } from "react";
+
+import { useCoinbaseOnrampOptions } from "./useCoinbaseOnrampOptions";
+import { useGetGeo } from "./useGetGeo";
+import { useStripeSupport } from "./useStripeSupport";
+
+export function useGeoOnrampOptions(isMainnet: boolean, srcFiatAmount: string) {
+  // Use existing hooks
+  const { geoData, loading: isLoadingGeo, error: geoError } = useGetGeo();
+  const { coinbaseOnrampOptions, isLoadingCoinbaseOnrampOptions, coinbaseOnrampOptionsError } =
+    useCoinbaseOnrampOptions(isMainnet, geoData?.country);
+  const { isStripeOnrampSupported, isStripeWeb2Supported, isLoadingStripeSupport, stripeSupportError } =
+    useStripeSupport(isMainnet, geoData?.ip || "", srcFiatAmount);
+
+  // Calculate available payment methods based on the amount
+  const coinbaseAvailablePaymentMethods = useMemo(() => {
+    if (!coinbaseOnrampOptions?.paymentCurrencies?.[0]?.limits || !srcFiatAmount) return [];
+    const amountNum = parseFloat(srcFiatAmount);
+    if (isNaN(amountNum)) return [];
+
+    return coinbaseOnrampOptions.paymentCurrencies[0].limits.filter((limit: any) => {
+      const min = parseFloat(limit.min);
+      const max = parseFloat(limit.max);
+      return amountNum >= min && amountNum <= max;
+    });
+  }, [coinbaseOnrampOptions, srcFiatAmount]);
+
+  return useMemo(
+    () => ({
+      geoData,
+      coinbaseOnrampOptions,
+      coinbaseAvailablePaymentMethods,
+      isStripeOnrampSupported,
+      isStripeWeb2Supported,
+      isOnrampSupported: coinbaseAvailablePaymentMethods.length > 0 || isStripeOnrampSupported || isStripeWeb2Supported,
+      isLoading: isLoadingGeo || isLoadingCoinbaseOnrampOptions || isLoadingStripeSupport,
+      isLoadingGeo,
+      isLoadingCoinbaseOnrampOptions,
+      isLoadingStripeSupport,
+      geoError,
+      coinbaseOnrampOptionsError,
+      stripeSupportError
+    }),
+    [
+      geoData,
+      coinbaseOnrampOptions,
+      coinbaseAvailablePaymentMethods,
+      isStripeOnrampSupported,
+      isStripeWeb2Supported,
+      isLoadingGeo,
+      isLoadingCoinbaseOnrampOptions,
+      isLoadingStripeSupport,
+      geoError,
+      coinbaseOnrampOptionsError,
+      stripeSupportError
+    ]
+  );
+}

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

@@ -0,0 +1,31 @@
+import { useQuery } from "@tanstack/react-query";
+
+export interface GeoData {
+  country: string;
+  city: string;
+  ip: string;
+  continent: string;
+  latitude: string;
+  longitude: string;
+  region: string;
+  regionCode: string;
+  timezone: string;
+}
+
+async function fetchGeoData(): Promise<GeoData> {
+  const response = await fetch("https://geo.basement.fun/");
+  if (!response.ok) {
+    throw new Error("Failed to fetch geo data");
+  }
+  return response.json();
+}
+
+export function useGetGeo() {
+  const {
+    data: geoData,
+    isLoading: loading,
+    error
+  } = useQuery({ queryKey: ["useGetGeo"], queryFn: fetchGeoData, retry: 3 });
+
+  return { geoData, loading, error };
+}