@b3dotfun/sdk 0.0.44 → 0.0.46

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

@@ -18,6 +18,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "swap";
         payload: import("../..").components["schemas"]["SwapPayload"];
@@ -41,6 +44,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "hype_duel";
         payload: import("../..").components["schemas"]["HypeDuelPayload"];
@@ -64,6 +70,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "custom";
         payload: import("../..").components["schemas"]["CustomPayload"];
@@ -87,6 +96,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "mint_nft";
         payload: import("../..").components["schemas"]["MintNftPayload"];
@@ -110,6 +122,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "join_tournament";
         payload: import("../..").components["schemas"]["JoinTournamentPayload"];
@@ -133,6 +148,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "fund_tournament";
         payload: import("../..").components["schemas"]["FundTournamentPayload"];
@@ -159,6 +177,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "swap";
         payload: import("../..").components["schemas"]["SwapPayload"];
@@ -182,6 +203,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "hype_duel";
         payload: import("../..").components["schemas"]["HypeDuelPayload"];
@@ -205,6 +229,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "custom";
         payload: import("../..").components["schemas"]["CustomPayload"];
@@ -228,6 +255,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "mint_nft";
         payload: import("../..").components["schemas"]["MintNftPayload"];
@@ -251,6 +281,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "join_tournament";
         payload: import("../..").components["schemas"]["JoinTournamentPayload"];
@@ -274,6 +307,9 @@ export declare function useAnyspendOrderHistory(creatorAddress: string | undefin
         onrampMetadata: import("../..").components["schemas"]["OnrampMetadata"] | null;
         oneClickBuyUrl: string | null;
         stripePaymentIntentId: string | null;
+        settlement: {
+            actualDstAmount: string | null;
+        } | null;
     } & {
         type: "fund_tournament";
         payload: import("../..").components["schemas"]["FundTournamentPayload"];

package/dist/esm/anyspend/types/api.d.ts

@@ -434,6 +434,11 @@ export interface paths {
                                 executeTx: components["schemas"]["ExecuteTx"] | null;
                                 /** @description Refund transactions if order failed */
                                 refundTxs: components["schemas"]["RefundTx"][];
+                                /**
+                                 * @description Points awarded for this order (only present when order status is executed)
+                                 * @example 100
+                                 */
+                                points: number | null;
                             };
                             /** @example 200 */
                             statusCode: number;
@@ -1112,11 +1117,6 @@ export interface components {
              * @example 990000
              */
             expectedDstAmount: string;
-            /**
-             * @description Actual received amount (null for new orders)
-             * @example 990000
-             */
-            actualDstAmount: string | null;
         };
         /** @description HypeDuel-specific payload */
         HypeDuelPayload: {
@@ -1125,11 +1125,6 @@ export interface components {
              * @example 990000
              */
             expectedDstAmount: string;
-            /**
-             * @description Actual received amount (null for new orders)
-             * @example 990000
-             */
-            actualDstAmount: string | null;
         };
         /** @description Custom execution payload */
         CustomPayload: {
@@ -1315,6 +1310,14 @@ export interface components {
              * @example pi_3Rko0sJnoDg53PsP0PDLsHkR
              */
             stripePaymentIntentId: string | null;
+            /** @description Settlement information for executed orders */
+            settlement: {
+                /**
+                 * @description Actual received amount after execution
+                 * @example 990000
+                 */
+                actualDstAmount: string | null;
+            } | null;
         };
         SwapOrder: components["schemas"]["BaseOrder"] & {
             /**

package/dist/esm/anyspend/utils/orderPayload.js

@@ -5,8 +5,6 @@ export const buildPayload = (orderType, params) => {
         case "swap":
             return {
                 expectedDstAmount,
-                actualDstAmount: null,
-                amountInAfterFee: null,
             };
         case "mint_nft":
             if (nft?.type === "erc1155") {
@@ -43,8 +41,6 @@ export const buildPayload = (orderType, params) => {
         case "hype_duel":
             return {
                 expectedDstAmount,
-                actualDstAmount: null,
-                amountInAfterFee: null,
             };
         default:
             throw new Error(`Invalid order type: ${orderType}`);

package/dist/esm/notifications/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./services";
+export { getAuthToken } from "../shared/utils/auth-token";

package/dist/esm/notifications/index.js

@@ -0,0 +1,7 @@
+// Export types
+export * from "./types/index.js";
+// Export services
+export * from "./services/index.js";
+// Re-export auth token getter from shared for convenience
+// Note: Auth token is managed by B3 Global Account authentication
+export { getAuthToken } from "../shared/utils/auth-token.js";

package/dist/esm/notifications/react/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from "./useNotifications";

package/dist/esm/notifications/react/hooks/index.js

@@ -0,0 +1 @@
+export * from "./useNotifications.js";

package/dist/esm/notifications/react/hooks/useNotifications.d.ts

@@ -0,0 +1,42 @@
+import type { UserData } from "../../types";
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '../../../notifications/react';
+ *
+ * function NotificationSettings() {
+ *   const { user, loading, connectEmail, connectTelegram, isEmailConnected } = useNotifications();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {!isEmailConnected && (
+ *         <button onClick={() => connectEmail('user@example.com')}>
+ *           Connect Email
+ *         </button>
+ *       )}
+ *       <button onClick={connectTelegram}>Connect Telegram</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useNotifications(): {
+    user: UserData | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    connectEmail: (email: string) => Promise<void>;
+    connectTelegram: () => Promise<void>;
+    updateChannel: (channelId: string, updates: {
+        enabled?: boolean;
+    }) => Promise<void>;
+    deleteChannel: (channelId: string) => Promise<void>;
+    isEmailConnected: boolean;
+    isTelegramConnected: boolean;
+    isDiscordConnected: boolean;
+};

package/dist/esm/notifications/react/hooks/useNotifications.js

@@ -0,0 +1,145 @@
+import { useEffect, useRef, useState } from "react";
+import { notificationsAPI } from "../../services/api.js";
+/**
+ * React hook for managing B3 notifications
+ * Automatically uses the authenticated user's ID from JWT
+ *
+ * @example
+ * ```tsx
+ * import { useNotifications } from '../../../notifications/react/index.js';
+ *
+ * function NotificationSettings() {
+ *   const { user, loading, connectEmail, connectTelegram, isEmailConnected } = useNotifications();
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *
+ *   return (
+ *     <div>
+ *       {!isEmailConnected && (
+ *         <button onClick={() => connectEmail('user@example.com')}>
+ *           Connect Email
+ *         </button>
+ *       )}
+ *       <button onClick={connectTelegram}>Connect Telegram</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useNotifications() {
+    const [user, setUser] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    // Refs to track polling timers for cleanup
+    const telegramPollIntervalRef = useRef(null);
+    const telegramPollTimeoutRef = useRef(null);
+    // Cleanup function for Telegram polling
+    const cleanupTelegramPolling = () => {
+        if (telegramPollIntervalRef.current) {
+            clearInterval(telegramPollIntervalRef.current);
+            telegramPollIntervalRef.current = null;
+        }
+        if (telegramPollTimeoutRef.current) {
+            clearTimeout(telegramPollTimeoutRef.current);
+            telegramPollTimeoutRef.current = null;
+        }
+    };
+    // Load user data on mount
+    useEffect(() => {
+        loadUser();
+    }, []);
+    // Cleanup polling on unmount
+    useEffect(() => {
+        return () => {
+            cleanupTelegramPolling();
+        };
+    }, []);
+    const loadUser = async () => {
+        try {
+            setLoading(true);
+            setError(null);
+            const userData = await notificationsAPI.getUser();
+            setUser(userData);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error("Failed to load user"));
+            console.error("Failed to load user:", err);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const connectEmail = async (email) => {
+        try {
+            await notificationsAPI.connectEmail(email);
+            await loadUser(); // Refresh user data
+        }
+        catch (err) {
+            console.error("Failed to connect email:", err);
+            throw err;
+        }
+    };
+    const connectTelegram = async () => {
+        try {
+            // Clear any existing polling before starting new one
+            cleanupTelegramPolling();
+            const { deepLink } = await notificationsAPI.getTelegramLink();
+            window.open(deepLink, "_blank");
+            // Poll for connection status
+            telegramPollIntervalRef.current = setInterval(async () => {
+                try {
+                    const { connected } = await notificationsAPI.checkTelegramStatus();
+                    if (connected) {
+                        cleanupTelegramPolling();
+                        await loadUser(); // Refresh user data
+                    }
+                }
+                catch (err) {
+                    console.error("Failed to check Telegram status:", err);
+                }
+            }, 2000);
+            // Stop polling after 2 minutes
+            telegramPollTimeoutRef.current = setTimeout(() => {
+                cleanupTelegramPolling();
+            }, 120000);
+        }
+        catch (err) {
+            console.error("Failed to connect Telegram:", err);
+            throw err;
+        }
+    };
+    const updateChannel = async (channelId, updates) => {
+        try {
+            await notificationsAPI.updateChannel(channelId, updates);
+            await loadUser(); // Refresh user data
+        }
+        catch (err) {
+            console.error("Failed to update channel:", err);
+            throw err;
+        }
+    };
+    const deleteChannel = async (channelId) => {
+        try {
+            await notificationsAPI.deleteChannel(channelId);
+            await loadUser(); // Refresh user data
+        }
+        catch (err) {
+            console.error("Failed to delete channel:", err);
+            throw err;
+        }
+    };
+    return {
+        user,
+        loading,
+        error,
+        refresh: loadUser,
+        connectEmail,
+        connectTelegram,
+        updateChannel,
+        deleteChannel,
+        // Convenience helpers
+        isEmailConnected: user?.channels?.find(c => c.channel_type === "email")?.enabled === 1,
+        isTelegramConnected: user?.channels?.find(c => c.channel_type === "telegram")?.enabled === 1,
+        isDiscordConnected: user?.channels?.find(c => c.channel_type === "discord")?.enabled === 1,
+    };
+}

package/dist/esm/notifications/react/index.d.ts

@@ -0,0 +1 @@
+export * from "./hooks";

package/dist/esm/notifications/react/index.js

@@ -0,0 +1 @@
+export * from "./hooks/index.js";

package/dist/esm/notifications/services/api.d.ts

@@ -0,0 +1,67 @@
+import type { NotificationHistory, NotificationPreferences, SendNotificationRequest, TelegramLinkResponse, TelegramStatusResponse, UserData } from "../types";
+export declare function setApiUrl(url: string): void;
+export declare function getApiUrl(): string;
+export declare const notificationsAPI: {
+    /**
+     * Register the current user (userId extracted from JWT)
+     */
+    registerUser(): Promise<any>;
+    /**
+     * Get current user's profile and preferences
+     */
+    getUser(): Promise<UserData>;
+    /**
+     * Get current user's notification history
+     */
+    getHistory(appId?: string, limit?: number): Promise<NotificationHistory[]>;
+    /**
+     * Add a notification channel for current user
+     */
+    addChannel(channelType: string, channelIdentifier: string, metadata?: Record<string, any>): Promise<any>;
+    /**
+     * Connect email for current user
+     */
+    connectEmail(email: string): Promise<any>;
+    /**
+     * Update a notification channel
+     */
+    updateChannel(channelId: string, updates: {
+        enabled?: boolean;
+        channelIdentifier?: string;
+        metadata?: Record<string, any>;
+    }): Promise<any>;
+    /**
+     * Delete a notification channel
+     */
+    deleteChannel(channelId: string): Promise<any>;
+    /**
+     * Get Telegram deep link for current user
+     */
+    getTelegramLink(): Promise<TelegramLinkResponse>;
+    /**
+     * Check current user's Telegram connection status
+     */
+    checkTelegramStatus(): Promise<TelegramStatusResponse>;
+    /**
+     * Save notification preferences for an app
+     * @param appId - The application ID
+     * @param settings - Notification preferences including channels, type, and enabled status (defaults to true)
+     */
+    savePreferences(appId: string, settings: NotificationPreferences): Promise<any>;
+    /**
+     * Get notification settings for an app
+     */
+    getAppSettings(appId: string): Promise<any>;
+    /**
+     * Get current user's in-app notifications
+     */
+    getInAppNotifications(): Promise<any>;
+    /**
+     * Mark a notification as read
+     */
+    markNotificationAsRead(notificationId: string): Promise<any>;
+    /**
+     * Send a notification (requires auth)
+     */
+    sendNotification(data: SendNotificationRequest): Promise<any>;
+};

package/dist/esm/notifications/services/api.js

@@ -0,0 +1,179 @@
+import { getAuthToken } from "../../shared/utils/auth-token.js";
+const DEFAULT_API_URL = "https://notifications.b3.fun";
+let apiUrl = DEFAULT_API_URL;
+export function setApiUrl(url) {
+    apiUrl = url;
+}
+export function getApiUrl() {
+    return apiUrl;
+}
+function getHeaders(includeAuth = false) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (includeAuth) {
+        const token = getAuthToken();
+        if (token) {
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+    }
+    return headers;
+}
+export const notificationsAPI = {
+    // ===== USER MANAGEMENT =====
+    /**
+     * Register the current user (userId extracted from JWT)
+     */
+    async registerUser() {
+        const res = await fetch(`${apiUrl}/users`, {
+            method: "POST",
+            headers: getHeaders(true),
+        });
+        if (!res.ok) {
+            const errorBody = await res.text().catch(() => "Could not read error body");
+            throw new Error(`API Error: ${res.status} ${res.statusText} - ${errorBody}`);
+        }
+        return res.json();
+    },
+    /**
+     * Get current user's profile and preferences
+     */
+    async getUser() {
+        const res = await fetch(`${apiUrl}/users/me`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Get current user's notification history
+     */
+    async getHistory(appId, limit = 100) {
+        const params = new URLSearchParams();
+        if (appId)
+            params.append("appId", appId);
+        params.append("limit", limit.toString());
+        const res = await fetch(`${apiUrl}/users/me/history?${params}`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== CHANNELS =====
+    /**
+     * Add a notification channel for current user
+     */
+    async addChannel(channelType, channelIdentifier, metadata) {
+        const res = await fetch(`${apiUrl}/users/me/channels`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify({
+                channelType,
+                channelIdentifier,
+                enabled: true,
+                metadata,
+            }),
+        });
+        return res.json();
+    },
+    /**
+     * Connect email for current user
+     */
+    async connectEmail(email) {
+        return this.addChannel("email", email);
+    },
+    /**
+     * Update a notification channel
+     */
+    async updateChannel(channelId, updates) {
+        const res = await fetch(`${apiUrl}/users/me/channels/${channelId}`, {
+            method: "PUT",
+            headers: getHeaders(true),
+            body: JSON.stringify(updates),
+        });
+        return res.json();
+    },
+    /**
+     * Delete a notification channel
+     */
+    async deleteChannel(channelId) {
+        const res = await fetch(`${apiUrl}/users/me/channels/${channelId}`, {
+            method: "DELETE",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== TELEGRAM =====
+    /**
+     * Get Telegram deep link for current user
+     */
+    async getTelegramLink() {
+        const res = await fetch(`${apiUrl}/telegram/request-link`, {
+            method: "POST",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Check current user's Telegram connection status
+     */
+    async checkTelegramStatus() {
+        const res = await fetch(`${apiUrl}/telegram/status/me`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== APP PREFERENCES =====
+    /**
+     * Save notification preferences for an app
+     * @param appId - The application ID
+     * @param settings - Notification preferences including channels, type, and enabled status (defaults to true)
+     */
+    async savePreferences(appId, settings) {
+        const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify({ enabled: true, ...settings }),
+        });
+        return res.json();
+    },
+    /**
+     * Get notification settings for an app
+     */
+    async getAppSettings(appId) {
+        const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== IN-APP NOTIFICATIONS =====
+    /**
+     * Get current user's in-app notifications
+     */
+    async getInAppNotifications() {
+        const res = await fetch(`${apiUrl}/users/me/notifications`, {
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    /**
+     * Mark a notification as read
+     */
+    async markNotificationAsRead(notificationId) {
+        const res = await fetch(`${apiUrl}/users/me/notifications/${notificationId}/read`, {
+            method: "PUT",
+            headers: getHeaders(true),
+        });
+        return res.json();
+    },
+    // ===== SENDING NOTIFICATIONS =====
+    /**
+     * Send a notification (requires auth)
+     */
+    async sendNotification(data) {
+        const res = await fetch(`${apiUrl}/send`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify(data),
+        });
+        return res.json();
+    },
+};

package/dist/esm/notifications/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./api";

package/dist/esm/notifications/services/index.js

@@ -0,0 +1 @@
+export * from "./api.js";