@b3dotfun/sdk 0.0.7-alpha.28 → 0.0.7-alpha.4

package/dist/esm/anyspend/react/hooks/useAnyspendOrderHistory.d.ts

@@ -41,12 +41,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             expectedDstAmount: string;
             actualDstAmount: string | null;
@@ -107,12 +113,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             contractAddress: string;
             tokenId: number | null;
@@ -167,12 +179,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             contractAddress: string;
             entryPrice: string;
@@ -225,12 +243,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             contractAddress: string;
             fundAmount: string;
@@ -278,12 +302,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             data: string;
             to: string;
@@ -335,12 +365,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             expectedDstAmount: string;
             actualDstAmount: string | null;
@@ -401,12 +437,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             contractAddress: string;
             tokenId: number | null;
@@ -461,12 +503,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             contractAddress: string;
             entryPrice: string;
@@ -519,12 +567,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             contractAddress: string;
             fundAmount: string;
@@ -572,12 +626,18 @@ export declare function useAnyspendOrderHistory(isMainnet: boolean, creatorAddre
             paymentMethod: string;
             redirectUrl: string;
             ipAddress?: string | undefined;
-            stripeAmountInCents?: number | undefined;
         } | null;
         creatorAddress: string | null;
         partnerId: string | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        permit: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        } | null;
         payload: {
             data: string;
             to: string;

package/dist/esm/anyspend/react/hooks/useAnyspendOrderHistory.js

@@ -1,17 +1,17 @@
 import { anyspendService } from "../../../anyspend/services/anyspend.js";
 import { useQuery } from "@tanstack/react-query";
 export function useAnyspendOrderHistory(isMainnet, creatorAddress, limit = 100, offset = 0) {
-    const { data: rawData = [], isLoading, refetch, error, } = useQuery({
+    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,
+        refetchOrderHistory: refetch
     };
 }

package/dist/esm/anyspend/react/hooks/useAnyspendQuote.js

@@ -20,7 +20,7 @@ import { useMemo } from "react";
  */
 export function useAnyspendQuote(isMainnet, req) {
     const { data, isLoading, refetch, error } = useQuery({
-        queryKey: ["useAnyspendQuote", isMainnet, JSON.stringify(req)],
+        queryKey: ["useAnyspendQuote", isMainnet, req],
         queryFn: () => {
             return anyspendService.getQuote(isMainnet, req);
         },
@@ -38,12 +38,12 @@ export function useAnyspendQuote(isMainnet, req) {
                             ? req.fundAmount
                             : req.payload.amount) !== BigInt(0)),
         refetchInterval: 10000,
-        retry: false,
+        retry: false
     });
     return useMemo(() => ({
         anyspendQuote: data,
         isLoadingAnyspendQuote: isLoading,
         getAnyspendQuoteError: error,
-        refetchAnyspendQuote: refetch,
+        refetchAnyspendQuote: refetch
     }), [data, error, isLoading, refetch]);
 }

package/dist/esm/anyspend/react/hooks/useAnyspendSendPermitData.d.ts

@@ -0,0 +1,16 @@
+import { UseAnyspendCreateOrderProps } from "./useAnyspendCreateOrder";
+export declare function useAnyspendSendPermitData({ onSuccess, onError }?: UseAnyspendCreateOrderProps): {
+    sendPermitData: import("@tanstack/react-query").UseMutateFunction<any, Error, {
+        orderId: string;
+        permitData: {
+            ownerAddress: string;
+            deadline: number;
+            v: number;
+            r: string;
+            s: string;
+        };
+    } & {
+        isMainnet: boolean;
+    }, unknown>;
+    isSendingPermitData: boolean;
+};

package/dist/esm/anyspend/react/hooks/useAnyspendSendPermitData.js

@@ -0,0 +1,36 @@
+import { anyspendService } from "../../../anyspend/services/anyspend.js";
+import { useMutation } from "@tanstack/react-query";
+export function useAnyspendSendPermitData({ onSuccess, onError } = {}) {
+    const { mutate: sendPermitData, isPending } = useMutation({
+        mutationFn: async ({ isMainnet, orderId, permitData }) => {
+            try {
+                const response = await anyspendService.sendPermitData({
+                    isMainnet,
+                    orderId,
+                    permitData
+                });
+                if (response.statusCode !== 200)
+                    throw response;
+                return response;
+            }
+            catch (error) {
+                // 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) => {
+            onError?.(error);
+        }
+    });
+    return {
+        sendPermitData,
+        isSendingPermitData: isPending
+    };
+}

package/dist/esm/anyspend/react/hooks/useAnyspendTokens.js

@@ -2,14 +2,14 @@ import { anyspendService } from "../../../anyspend/services/anyspend.js";
 import { useQuery } from "@tanstack/react-query";
 import { useMemo } from "react";
 export function useAnyspendTokenList(isMainnet, chainId, query) {
-    const { data = [], isLoading, refetch, } = useQuery({
+    const { data = [], isLoading, refetch } = useQuery({
         queryKey: ["getAnyspendTokenList", chainId, query],
         queryFn: () => anyspendService.getTokenList(isMainnet, chainId, query),
-        enabled: true,
+        enabled: true
     });
     return useMemo(() => ({
         data,
         isLoading,
-        refetch,
+        refetch
     }), [data, isLoading, refetch]);
 }

package/dist/esm/anyspend/react/hooks/useCoinbaseOnrampOptions.js

@@ -5,12 +5,12 @@ export function useCoinbaseOnrampOptions(isMainnet, country) {
     const { data, isLoading, error, refetch } = useQuery({
         queryKey: ["getCoinbaseOnrampOptions", isMainnet, country],
         queryFn: () => anyspendService.getCoinbaseOnrampOptions(isMainnet, country),
-        enabled: Boolean(country),
+        enabled: Boolean(country)
     });
     return useMemo(() => ({
         coinbaseOnrampOptions: data,
         isLoadingCoinbaseOnrampOptions: isLoading,
         coinbaseOnrampOptionsError: error,
-        refetchCoinbaseOnrampOptions: refetch,
+        refetchCoinbaseOnrampOptions: refetch
     }), [data, isLoading, error, refetch]);
 }

package/dist/esm/anyspend/react/hooks/useGeoOnrampOptions.js

@@ -33,7 +33,7 @@ export function useGeoOnrampOptions(isMainnet, srcFiatAmount) {
         isLoadingStripeSupport,
         geoError,
         coinbaseOnrampOptionsError,
-        stripeSupportError,
+        stripeSupportError
     }), [
         geoData,
         coinbaseOnrampOptions,
@@ -45,6 +45,6 @@ export function useGeoOnrampOptions(isMainnet, srcFiatAmount) {
         isLoadingStripeSupport,
         geoError,
         coinbaseOnrampOptionsError,
-        stripeSupportError,
+        stripeSupportError
     ]);
 }

package/dist/esm/anyspend/react/hooks/useGetGeo.js

@@ -7,6 +7,6 @@ async function fetchGeoData() {
     return response.json();
 }
 export function useGetGeo() {
-    const { data: geoData, isLoading: loading, error, } = useQuery({ queryKey: ["useGetGeo"], queryFn: fetchGeoData, retry: 3 });
+    const { data: geoData, isLoading: loading, error } = useQuery({ queryKey: ["useGetGeo"], queryFn: fetchGeoData, retry: 3 });
     return { geoData, loading, error };
 }

package/dist/esm/anyspend/react/hooks/usePermitData.d.ts

@@ -0,0 +1,92 @@
+import { Address, Hex } from "viem";
+export type GetPermitDataParams = {
+    chainId: number;
+    tokenAddress: Hex;
+    ownerAddress: Hex | undefined;
+    amount: bigint;
+};
+export declare function getPermitData(p: GetPermitDataParams): Promise<{
+    canPermit: boolean;
+    data: null;
+} | {
+    canPermit: boolean;
+    data: {
+        domain: {
+            name: string;
+            version: string;
+            chainId: number;
+            verifyingContract: `0x${string}`;
+        };
+        types: {
+            Permit: {
+                name: string;
+                type: string;
+            }[];
+        };
+        messageToSign: {
+            owner: `0x${string}`;
+            spender: Address;
+            value: bigint;
+            nonce: bigint;
+            deadline: bigint;
+        };
+    };
+}>;
+export declare function usePermitData(p: GetPermitDataParams): {
+    permitData: {
+        canPermit: boolean;
+        data: null;
+    } | {
+        canPermit: boolean;
+        data: {
+            domain: {
+                name: string;
+                version: string;
+                chainId: number;
+                verifyingContract: `0x${string}`;
+            };
+            types: {
+                Permit: {
+                    name: string;
+                    type: string;
+                }[];
+            };
+            messageToSign: {
+                owner: `0x${string}`;
+                spender: Address;
+                value: bigint;
+                nonce: bigint;
+                deadline: bigint;
+            };
+        };
+    } | undefined;
+    isCheckingPermit: boolean;
+    checkPermitError: Error | null;
+    recheckPermit: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<{
+        canPermit: boolean;
+        data: null;
+    } | {
+        canPermit: boolean;
+        data: {
+            domain: {
+                name: string;
+                version: string;
+                chainId: number;
+                verifyingContract: `0x${string}`;
+            };
+            types: {
+                Permit: {
+                    name: string;
+                    type: string;
+                }[];
+            };
+            messageToSign: {
+                owner: `0x${string}`;
+                spender: Address;
+                value: bigint;
+                nonce: bigint;
+                deadline: bigint;
+            };
+        };
+    }, Error>>;
+};

package/dist/esm/anyspend/react/hooks/usePermitData.js

@@ -0,0 +1,154 @@
+import { chainIdToPublicClient, getMulticall3Address, isEvmChain, isNativeToken } from "../../../anyspend/utils/index.js";
+import { useQuery } from "@tanstack/react-query";
+import { ABI_USDC_BASE } from "../../../anyspend/abis/abi-usdc-base.js";
+// 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"
+    }
+];
+export async function getPermitData(p) {
+    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;
+    let version = "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";
+    });
+    // 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,
+        value: p.amount,
+        nonce,
+        deadline: deadlineInSeconds
+    };
+    return {
+        canPermit: true,
+        data: {
+            domain,
+            types: { Permit: PermitType },
+            messageToSign
+        }
+    };
+}
+export function usePermitData(p) {
+    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/dist/esm/anyspend/react/hooks/useStripeClientSecret.js

@@ -4,12 +4,12 @@ import { anyspendService } from "../../../anyspend/services/anyspend.js";
 export function useStripeClientSecret(isMainnet, paymentIntentId) {
     const { data, isLoading, error, refetch } = useQuery({
         queryKey: ["stripeClientSecret", isMainnet, paymentIntentId],
-        queryFn: () => anyspendService.getStripeClientSecret(isMainnet, paymentIntentId),
+        queryFn: () => anyspendService.getStripeClientSecret(isMainnet, paymentIntentId)
     });
     return useMemo(() => ({
         clientSecret: data || null,
         isLoadingStripeClientSecret: isLoading,
         stripeClientSecretError: error,
-        refetchStripeClientSecret: refetch,
+        refetchStripeClientSecret: refetch
     }), [data, isLoading, error, refetch]);
 }

package/dist/esm/anyspend/react/hooks/useStripeSupport.js

@@ -5,13 +5,13 @@ export function useStripeSupport(isMainnet, ipAddress, usdAmount) {
     const { data, isLoading, error, refetch } = useQuery({
         queryKey: ["useStripeSupport", isMainnet, ipAddress, usdAmount],
         queryFn: () => anyspendService.checkStripeSupport(isMainnet, ipAddress, usdAmount),
-        enabled: !!ipAddress,
+        enabled: !!ipAddress
     });
     return useMemo(() => ({
         isStripeOnrampSupported: data?.stripeOnramp || false,
         isStripeWeb2Supported: data?.stripeWeb2 || false,
         isLoadingStripeSupport: isLoading,
         stripeSupportError: error,
-        refetchStripeSupport: refetch,
+        refetchStripeSupport: refetch
     }), [data, isLoading, error, refetch]);
 }

package/dist/esm/anyspend/react/providers/AnyspendProvider.js

@@ -1,6 +1,5 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { TooltipProvider } from "../../../global-account/react/index.js";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { useState } from "react";
 const defaultQueryClientConfig = {
@@ -8,9 +7,9 @@ const defaultQueryClientConfig = {
         queries: {
             refetchOnWindowFocus: false,
             retry: false,
-            staleTime: 30000,
-        },
-    },
+            staleTime: 30000
+        }
+    }
 };
 /**
  * AnyspendProvider is a top-level provider that wraps your application to provide
@@ -35,5 +34,5 @@ const defaultQueryClientConfig = {
  */
 export const AnyspendProvider = function AnyspendProvider({ children }) {
     const [queryClient] = useState(() => new QueryClient(defaultQueryClientConfig));
-    return (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(TooltipProvider, { children: children }) }));
+    return _jsx(QueryClientProvider, { client: queryClient, children: children });
 };