@b3dotfun/sdk 0.0.1-alpha.1

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

@@ -0,0 +1,183 @@
+import { chainIdToPublicClient, getMulticall3Address, isEvmChain, isNativeToken } from "@b3dotfun/sdk/anyspend/utils";
+import { useQuery } from "@tanstack/react-query";
+import { Address, Hex } from "viem";
+import { ABI_USDC_BASE } from "@b3dotfun/sdk/anyspend/abis/abi-usdc-base";
+
+export type GetPermitDataParams = {
+  chainId: number;
+  tokenAddress: Hex;
+  ownerAddress: Hex | undefined;
+  amount: bigint;
+};
+
+// EIP-5267 ABI for eip712Domain function
+const EIP5267_ABI = [
+  {
+    inputs: [],
+    name: "eip712Domain",
+    outputs: [
+      { name: "fields", type: "bytes1" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" },
+      { name: "salt", type: "bytes32" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+] as const;
+
+export async function getPermitData(p: GetPermitDataParams) {
+  console.log("Start getting permit data...");
+
+  if (!isEvmChain(p.chainId) || isNativeToken(p.tokenAddress) || !p.ownerAddress) {
+    return {
+      canPermit: false,
+      data: null
+    };
+  }
+
+  const publicClient = chainIdToPublicClient(p.chainId);
+
+  const balance = await publicClient.readContract({
+    address: p.tokenAddress,
+    abi: ABI_USDC_BASE,
+    functionName: "balanceOf",
+    args: [p.ownerAddress]
+  });
+  if (balance < p.amount) {
+    return {
+      canPermit: false,
+      data: null
+    };
+  }
+
+  // Domain parameters
+  let name: string;
+  let version: string = "1"; // Default version for EIP-2612 (used by Uniswap V2 reference implementation)
+
+  // Try to get domain information using EIP-5267 (eip712Domain function)
+  try {
+    const domainData = await publicClient.readContract({
+      address: p.tokenAddress,
+      abi: EIP5267_ABI,
+      functionName: "eip712Domain"
+    });
+
+    console.log("Found EIP-5267 eip712Domain function");
+    name = domainData[1]; // name is the second return value
+    version = domainData[2]; // version is the third return value
+
+    console.log("Contract domain data from EIP-5267:");
+    console.log("- name:", name);
+    console.log("- version:", version);
+    console.log("- chainId:", domainData[3]);
+    console.log("- verifyingContract:", domainData[4]);
+  } catch (error) {
+    console.log("[EIP-5267] eip712Domain function not found, falling back to individual calls");
+
+    // Fallback: get name from contract
+    name = await publicClient.readContract({
+      address: p.tokenAddress,
+      abi: ABI_USDC_BASE,
+      functionName: "name"
+    });
+
+    // Try to get version from contract
+    try {
+      version = await publicClient.readContract({
+        address: p.tokenAddress,
+        abi: ABI_USDC_BASE,
+        functionName: "version"
+      });
+    } catch (error) {
+      console.log(`Function "version" not found, using default version "1" (standard for EIP-2612)`);
+    }
+  }
+
+  // Fetch the PERMIT_TYPEHASH - important for ensuring our structure matches the contract
+  const permitTypeHash = await publicClient
+    .readContract({
+      address: p.tokenAddress,
+      abi: ABI_USDC_BASE,
+      functionName: "PERMIT_TYPEHASH"
+    })
+    .catch(() => {
+      console.log("PERMIT_TYPEHASH not directly accessible, using standard EIP-2612 value");
+      return "0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9" as `0x${string}`;
+    });
+
+  // Fetch the DOMAIN_SEPARATOR - critical for signature validation
+  const contractDomainSeparator = await publicClient.readContract({
+    address: p.tokenAddress,
+    abi: ABI_USDC_BASE,
+    functionName: "DOMAIN_SEPARATOR"
+  });
+
+  console.log("Contract name:", name);
+  console.log("Contract version:", version);
+  console.log("Contract PERMIT_TYPEHASH:", permitTypeHash);
+  console.log("Contract DOMAIN_SEPARATOR:", contractDomainSeparator);
+
+  // Domain data for EIP-712 signature
+  const domain = {
+    name,
+    version,
+    chainId: p.chainId,
+    verifyingContract: p.tokenAddress
+  };
+
+  // EIP-2612 Permit type definition
+  // This must match the structure used to compute the PERMIT_TYPEHASH in the contract
+  const PermitType = [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ];
+
+  const multicall3 = getMulticall3Address(p.chainId);
+
+  const nonce = await publicClient.readContract({
+    address: p.tokenAddress,
+    abi: ABI_USDC_BASE,
+    functionName: "nonces",
+    args: [p.ownerAddress]
+  });
+
+  const deadlineInSeconds = BigInt(Math.floor(Date.now() / 1000) + 60 * 60); // 60 minutes
+
+  // Permit data to sign
+  const messageToSign = {
+    owner: p.ownerAddress,
+    spender: multicall3 as Address,
+    value: p.amount,
+    nonce,
+    deadline: deadlineInSeconds
+  };
+
+  return {
+    canPermit: true,
+    data: {
+      domain,
+      types: { Permit: PermitType },
+      messageToSign
+    }
+  };
+}
+
+export function usePermitData(p: GetPermitDataParams) {
+  const { data, isLoading, error, refetch } = useQuery({
+    queryKey: ["usePermitData", p.chainId, p.tokenAddress],
+    queryFn: () => getPermitData(p)
+  });
+
+  return {
+    permitData: data,
+    isCheckingPermit: isLoading,
+    checkPermitError: error,
+    recheckPermit: refetch
+  };
+}

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

@@ -0,0 +1,20 @@
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+
+export function useStripeClientSecret(isMainnet: boolean, paymentIntentId: string) {
+  const { data, isLoading, error, refetch } = useQuery({
+    queryKey: ["stripeClientSecret", isMainnet, paymentIntentId],
+    queryFn: () => anyspendService.getStripeClientSecret(isMainnet, paymentIntentId)
+  });
+
+  return useMemo(
+    () => ({
+      clientSecret: data || null,
+      isLoadingStripeClientSecret: isLoading,
+      stripeClientSecretError: error,
+      refetchStripeClientSecret: refetch
+    }),
+    [data, isLoading, error, refetch]
+  );
+}

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

@@ -0,0 +1,22 @@
+import { anyspendService } from "@b3dotfun/sdk/anyspend/services/anyspend";
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+export function useStripeSupport(isMainnet: boolean, ipAddress: string, usdAmount?: string) {
+  const { data, isLoading, error, refetch } = useQuery({
+    queryKey: ["useStripeSupport", isMainnet, ipAddress, usdAmount],
+    queryFn: () => anyspendService.checkStripeSupport(isMainnet, ipAddress, usdAmount),
+    enabled: !!ipAddress
+  });
+
+  return useMemo(
+    () => ({
+      isStripeOnrampSupported: data?.stripeOnramp || false,
+      isStripeWeb2Supported: data?.stripeWeb2 || false,
+      isLoadingStripeSupport: isLoading,
+      stripeSupportError: error,
+      refetchStripeSupport: refetch
+    }),
+    [data, isLoading, error, refetch]
+  );
+}

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

@@ -0,0 +1,45 @@
+"use client";
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ReactNode, useState } from "react";
+
+interface AnyspendProviderProps {
+  children: ReactNode;
+}
+
+const defaultQueryClientConfig = {
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false,
+      retry: false,
+      staleTime: 30000
+    }
+  }
+} as const;
+
+/**
+ * AnyspendProvider is a top-level provider that wraps your application to provide
+ * query caching and state management for all Anyspend hooks.
+ *
+ * Features:
+ * - Memoized QueryClient instance to prevent unnecessary re-renders
+ * - Optimized for performance with React.memo
+ * - Safe to use at the application root
+ * - Configures sensible defaults for query caching
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <AnyspendProvider>
+ *       <YourApp />
+ *     </AnyspendProvider>
+ *   );
+ * }
+ * ```
+ */
+export const AnyspendProvider = function AnyspendProvider({ children }: AnyspendProviderProps) {
+  const [queryClient] = useState(() => new QueryClient(defaultQueryClientConfig));
+
+  return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+};

package/src/anyspend/services/anyspend.ts

@@ -0,0 +1,191 @@
+import {
+  GetOrderAndTxsResponse,
+  GetQuoteRequest,
+  GetQuoteResponse,
+  SendPermitDataRequestBody,
+  Token,
+  zGetCoinbaseOnrampOptionsResponse,
+  zGetOrderAndTxsResponse,
+  zGetOrderHistoryResponse,
+  zGetTokenListResponse
+} from "@b3dotfun/sdk/anyspend/types";
+import { getNativeToken, isNativeToken } from "@b3dotfun/sdk/anyspend/utils";
+import invariant from "invariant";
+import { ANYSPEND_MAINNET_BASE_URL, ANYSPEND_TESTNET_BASE_URL } from "@b3dotfun/sdk/anyspend/constants";
+import { OnrampOptions } from "@b3dotfun/sdk/anyspend/react/hooks";
+
+// Service functions
+export const anyspendService = {
+  getTokenList: async (isMainnet: boolean, chainId: number, query: string): Promise<Token[]> => {
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/chains/${chainId}/tokens?limit=100&term=${query}`
+    );
+    const data = await response.json();
+    invariant(response.status === 200, `Failed to fetch token list for chain ${chainId}`);
+    const parsedData = zGetTokenListResponse.parse(data);
+    return parsedData.data;
+  },
+
+  getToken: async (isMainnet: boolean, chainId: number, tokenAddress: string): Promise<Token> => {
+    if (isNativeToken(tokenAddress)) {
+      return getNativeToken(chainId);
+    }
+    const tokenList = await anyspendService.getTokenList(isMainnet, chainId, tokenAddress);
+    const token = tokenList.find((t: Token) => t.address.toLowerCase() === tokenAddress.toLowerCase());
+    if (!token) {
+      throw new Error(`Token ${tokenAddress} not found on chain ${chainId}`);
+    }
+    return token;
+  },
+
+  getQuote: async (isMainnet: boolean, req: GetQuoteRequest): Promise<GetQuoteResponse> => {
+    const url = `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders/quote`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(req)
+    });
+    const data = await response.json();
+    if (response.status !== 200) throw new Error(data.message);
+    return data as GetQuoteResponse;
+  },
+
+  // Order related
+  createOrder: async ({
+    isMainnet,
+    recipientAddress,
+    type,
+    srcChain,
+    dstChain,
+    srcTokenAddress,
+    dstTokenAddress,
+    srcAmount,
+    payload,
+    onramp,
+    metadata,
+    creatorAddress
+  }: {
+    isMainnet: boolean;
+    recipientAddress: string;
+    type: string;
+    srcChain: number;
+    dstChain: number;
+    srcTokenAddress: string;
+    dstTokenAddress: string;
+    srcAmount: string;
+    payload: Record<string, any>;
+    onramp?: OnrampOptions;
+    metadata: Record<string, any>;
+    creatorAddress?: string;
+  }) => {
+    const response = await fetch(`${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        recipientAddress,
+        type,
+        srcChain,
+        dstChain,
+        srcTokenAddress,
+        dstTokenAddress,
+        srcAmount,
+        payload,
+        onramp,
+        metadata,
+        creatorAddress
+      })
+    });
+    const data = await response.json();
+    invariant(data.statusCode === 200, data.message);
+    return data;
+  },
+
+  getOrderAndTransactions: async (isMainnet: boolean, orderId: string | undefined): Promise<GetOrderAndTxsResponse> => {
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders/${orderId}`
+    );
+    const responseData = await response.json();
+    const data = zGetOrderAndTxsResponse.parse(responseData);
+
+    return data;
+  },
+
+  getOrderHistory: async (
+    isMainnet: boolean,
+    creatorAddress: string | undefined,
+    limit: number = 100,
+    offset: number = 0
+  ) => {
+    const params = new URLSearchParams({
+      limit: limit.toString(),
+      offset: offset.toString()
+    });
+    if (creatorAddress) {
+      params.append("creatorAddress", creatorAddress);
+    }
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders?${params.toString()}`
+    );
+    const responseData = await response.json();
+    const data = zGetOrderHistoryResponse.parse(responseData);
+    return data;
+  },
+
+  getCoinbaseOnrampOptions: async (isMainnet: boolean, country: string) => {
+    const params = new URLSearchParams({
+      country
+    });
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/onramp/coinbase/options?${params.toString()}`
+    );
+    const data = await response.json();
+    const parsedData = zGetCoinbaseOnrampOptionsResponse.parse(data.data);
+    return parsedData;
+  },
+
+  checkStripeSupport: async (
+    isMainnet: boolean,
+    ipAddress: string,
+    usdAmount?: string
+  ): Promise<{ stripeOnramp: boolean; stripeWeb2: boolean }> => {
+    const params = new URLSearchParams({
+      ipAddress,
+      usdAmount: usdAmount || ""
+    });
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/onramp/stripe/supported?${params.toString()}`
+    );
+    const data = await response.json();
+    invariant(response.status === 200, "Failed to check Stripe support");
+    return data.data;
+  },
+
+  sendPermitData: async ({ isMainnet, orderId, permitData }: SendPermitDataRequestBody & { isMainnet: boolean }) => {
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/orders/send-permit`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          orderId,
+          permitData
+        })
+      }
+    );
+    return response.json();
+  },
+
+  getStripeClientSecret: async (isMainnet: boolean, paymentIntentId: string): Promise<string | null> => {
+    const response = await fetch(
+      `${isMainnet ? ANYSPEND_MAINNET_BASE_URL : ANYSPEND_TESTNET_BASE_URL}/stripe/clientSecret?paymentIntentId=${paymentIntentId}`
+    );
+    const data = await response.json();
+    return data.data;
+  }
+};

package/src/anyspend/types/chain.ts

@@ -0,0 +1,30 @@
+import { Chain } from "viem";
+import { Token } from "./token";
+
+export enum ChainType {
+  EVM = "evm",
+  SOLANA = "solana"
+}
+
+export interface IBaseChain {
+  id: number;
+  name: string;
+  type: ChainType;
+  logoUrl: string;
+  nativeRequired: bigint;
+  canDepositNative: boolean;
+  defaultToken: Token;
+  nativeToken: Token;
+}
+
+export interface IEVMChain extends IBaseChain {
+  type: ChainType.EVM;
+  viem: Chain;
+  pollingInterval: number;
+  zapperEnum?: string;
+  coingeckoName?: string;
+}
+
+export interface ISolanaChain extends IBaseChain {
+  type: ChainType.SOLANA;
+}

package/src/anyspend/types/custom.ts

@@ -0,0 +1,17 @@
+import z from "zod";
+import { zToken } from "./token";
+
+export const zCustomPayload = z.object({
+  data: z.string(),
+  to: z.string(),
+  spenderAddress: z.string().optional(),
+  amount: z.string()
+});
+export type CustomPayload = z.infer<typeof zCustomPayload>;
+
+export const zCustomMetadata = z.object({
+  srcToken: zToken,
+  dstToken: zToken,
+  action: z.string().optional()
+});
+export type CustomMetadata = z.infer<typeof zCustomMetadata>;

package/src/anyspend/types/globalWallet.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const zGlobalWallet = z.object({
+  chain: z.number(),
+  encryptedPrvkey: z.string(),
+  address: z.string(),
+  orderId: z.string().nullable()
+});
+export type GlobalWallet = z.infer<typeof zGlobalWallet>;

package/src/anyspend/types/index.ts

@@ -0,0 +1,14 @@
+export * from "./req-res";
+
+export * from "./chain";
+export * from "./custom";
+export * from "./globalWallet";
+export * from "./nft";
+export * from "./onramp";
+export * from "./order";
+export * from "./permit";
+export * from "./relay";
+export * from "./swap";
+export * from "./token";
+export * from "./tournament";
+export * from "./transaction";

package/src/anyspend/types/nft.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Token, zToken } from "./token";
+
+export enum NftType {
+  ERC721 = "erc721",
+  ERC1155 = "erc1155"
+}
+
+export const zBaseNft = z.object({
+  type: z.nativeEnum(NftType),
+  contractAddress: z.string(),
+  name: z.string(),
+  description: z.string(),
+  imageUrl: z.string()
+});
+
+export const zNft = z.discriminatedUnion("type", [
+  zBaseNft.extend({
+    type: z.literal(NftType.ERC721)
+  }),
+  zBaseNft.extend({
+    type: z.literal(NftType.ERC1155),
+    tokenId: z.number(),
+    imageUrl: z.string()
+  })
+]);
+export type Nft = z.infer<typeof zNft>;
+
+export const zMintNftPayload = z.object({
+  contractAddress: z.string(),
+  nftPrice: z.string()
+});
+
+export const zMintNftMetadata = z.object({
+  srcToken: zToken,
+  dstToken: zToken,
+  nft: zNft
+});
+
+export interface NftContract {
+  chainId: number;
+  contractAddress: string;
+  price: string;
+  priceFormatted: string;
+  currency: Token;
+  imageUrl: string;
+  name: string;
+  description: string;
+  tokenId: number | null;
+}

package/src/anyspend/types/onramp.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+export enum OnrampVendor {
+  Coinbase = "coinbase",
+  Stripe = "stripe",
+  StripeWeb2 = "stripe-web2"
+}
+
+export const zOnrampMetadata = z.object({
+  country: z.string(),
+  vendor: z.nativeEnum(OnrampVendor),
+  paymentMethod: z.string(),
+  ipAddress: z.string().ip("Invalid IP address").optional(),
+  redirectUrl: z.string()
+});

package/src/anyspend/types/order.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { zOnrampMetadata } from "./onramp";
+import { zPermit } from "./permit";
+import { zMintNftMetadata, zMintNftPayload } from "./nft";
+import { zSwapMetadata, zSwapPayload } from "./swap";
+import { zFundTournamentPayload, zJoinTournamentPayload, zTournamentMetadata } from "./tournament";
+import { zCustomMetadata, zCustomPayload } from "./custom";
+
+export enum OrderStatus {
+  // Prepare steps: For non-permit orders
+  ScanningDepositTransaction = "scanning_deposit_transaction",
+  WaitingStripePayment = "waiting_stripe_payment",
+
+  // Prepare steps: For permit orders
+  ObtainToken = "obtain_token",
+  ObtainFailed = "obtain_failed",
+
+  //
+  Expired = "expired",
+
+  //
+  SendingTokenFromVault = "sending_token_from_vault",
+
+  // Execute steps
+  Relay = "relay",
+  Executed = "executed",
+
+  // Refund steps
+  Refunding = "refunding",
+  Refunded = "refunded",
+
+  // Failed order
+  Failure = "failure"
+}
+
+export enum OrderType {
+  Swap = "swap",
+  MintNFT = "mint_nft",
+  JoinTournament = "join_tournament",
+  FundTournament = "fund_tournament",
+  Custom = "custom"
+}
+
+export const zBaseOrder = z.object({
+  id: z.string(),
+
+  recipientAddress: z.string(),
+  globalAddress: z.string(),
+  srcChain: z.number(),
+  dstChain: z.number(),
+  srcTokenAddress: z.string(),
+  dstTokenAddress: z.string(),
+  srcAmount: z.string(),
+  status: z.nativeEnum(OrderStatus),
+  errorDetails: z.string().nullable(),
+  createdAt: z.number(),
+  expiredAt: z.number(),
+  onrampMetadata: zOnrampMetadata.nullable(),
+  creatorAddress: z.string().nullable(),
+
+  oneClickBuyUrl: z.string().nullable(),
+  stripePaymentIntentId: z.string().nullable(),
+
+  permit: zPermit.nullable()
+});
+
+export const zOrder = z.discriminatedUnion("type", [
+  zBaseOrder.extend({
+    type: z.literal(OrderType.Swap),
+    payload: zSwapPayload,
+    metadata: zSwapMetadata
+  }),
+  zBaseOrder.extend({
+    type: z.literal(OrderType.MintNFT),
+    payload: zMintNftPayload,
+    metadata: zMintNftMetadata
+  }),
+  zBaseOrder.extend({
+    type: z.literal(OrderType.JoinTournament),
+    payload: zJoinTournamentPayload,
+    metadata: zTournamentMetadata
+  }),
+  zBaseOrder.extend({
+    type: z.literal(OrderType.FundTournament),
+    payload: zFundTournamentPayload,
+    metadata: zTournamentMetadata
+  }),
+  zBaseOrder.extend({
+    type: z.literal(OrderType.Custom),
+    payload: zCustomPayload,
+    metadata: zCustomMetadata
+  })
+]);
+export type Order = z.infer<typeof zOrder>;