@b3dotfun/sdk 0.0.44 → 0.0.45

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNotifications = useNotifications;
+const react_1 = require("react");
+const api_1 = require("../../services/api");
+/**
+ * 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>
+ *   );
+ * }
+ * ```
+ */
+function useNotifications() {
+    const [user, setUser] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    // Refs to track polling timers for cleanup
+    const telegramPollIntervalRef = (0, react_1.useRef)(null);
+    const telegramPollTimeoutRef = (0, react_1.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
+    (0, react_1.useEffect)(() => {
+        loadUser();
+    }, []);
+    // Cleanup polling on unmount
+    (0, react_1.useEffect)(() => {
+        return () => {
+            cleanupTelegramPolling();
+        };
+    }, []);
+    const loadUser = async () => {
+        try {
+            setLoading(true);
+            setError(null);
+            const userData = await api_1.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 api_1.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 api_1.notificationsAPI.getTelegramLink();
+            window.open(deepLink, "_blank");
+            // Poll for connection status
+            telegramPollIntervalRef.current = setInterval(async () => {
+                try {
+                    const { connected } = await api_1.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 api_1.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 api_1.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/cjs/notifications/react/index.d.ts

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);

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

@@ -0,0 +1,65 @@
+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
+     */
+    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/cjs/notifications/services/api.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notificationsAPI = void 0;
+exports.setApiUrl = setApiUrl;
+exports.getApiUrl = getApiUrl;
+const auth_token_1 = require("../../shared/utils/auth-token");
+const DEFAULT_API_URL = "https://notifications.b3.fun";
+let apiUrl = DEFAULT_API_URL;
+function setApiUrl(url) {
+    apiUrl = url;
+}
+function getApiUrl() {
+    return apiUrl;
+}
+function getHeaders(includeAuth = false) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (includeAuth) {
+        const token = (0, auth_token_1.getAuthToken)();
+        if (token) {
+            headers["Authorization"] = `Bearer ${token}`;
+        }
+    }
+    return headers;
+}
+exports.notificationsAPI = {
+    // ===== USER MANAGEMENT =====
+    /**
+     * Register the current user (userId extracted from JWT)
+     */
+    async registerUser() {
+        const res = await fetch(`${apiUrl}/users`, {
+            method: "POST",
+            headers: getHeaders(true),
+        });
+        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
+     */
+    async savePreferences(appId, settings) {
+        const res = await fetch(`${apiUrl}/users/me/apps/${appId}/settings`, {
+            method: "POST",
+            headers: getHeaders(true),
+            body: JSON.stringify({ ...settings, enabled: true }),
+        });
+        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/cjs/notifications/services/index.d.ts

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);

package/dist/cjs/notifications/types/index.d.ts

@@ -0,0 +1,50 @@
+export type ChannelType = "email" | "telegram" | "discord" | "sms" | "whatsapp" | "in_app";
+export interface NotificationChannel {
+    id: number;
+    channel_type: ChannelType;
+    enabled: number;
+    channel_identifier: string;
+}
+export interface UserData {
+    user: {
+        id: number;
+        user_id: string;
+    };
+    channels: NotificationChannel[];
+    appSettings: Array<{
+        app_id: string;
+        notification_type: string;
+        enabled: number;
+        channels: string;
+    }>;
+}
+export interface NotificationHistory {
+    id: string;
+    app_id: string;
+    notification_type: string;
+    title: string;
+    message: string;
+    created_at: string;
+    read: boolean;
+}
+export interface TelegramLinkResponse {
+    deepLink: string;
+    verificationCode: string;
+    botUsername: string;
+}
+export interface TelegramStatusResponse {
+    connected: boolean;
+    chatId?: string;
+}
+export interface NotificationPreferences {
+    notificationType: string;
+    channels: string[];
+}
+export interface SendNotificationRequest {
+    userId: string;
+    appId: string;
+    notificationType: string;
+    message: string;
+    title?: string;
+    data?: Record<string, any>;
+}

package/dist/cjs/notifications/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/shared/utils/auth-token.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the authentication token from the B3 auth cookie
+ * This token is managed by the B3 Global Account authentication system
+ *
+ * @returns The JWT token string or null if not found
+ */
+export declare function getAuthToken(): string | null;

package/dist/cjs/shared/utils/auth-token.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthToken = getAuthToken;
+const js_cookie_1 = __importDefault(require("js-cookie"));
+const B3_AUTH_COOKIE_NAME = "b3-auth";
+/**
+ * Get the authentication token from the B3 auth cookie
+ * This token is managed by the B3 Global Account authentication system
+ *
+ * @returns The JWT token string or null if not found
+ */
+function getAuthToken() {
+    return js_cookie_1.default.get(B3_AUTH_COOKIE_NAME) || null;
+}

package/dist/cjs/shared/utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./auth-token";
 export * from "./cn";
 export * from "./formatNumber";
 export * from "./formatUsername";

package/dist/cjs/shared/utils/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // Export utility functions
+__exportStar(require("./auth-token"), exports);
 __exportStar(require("./cn"), exports);
 __exportStar(require("./formatNumber"), exports);
 __exportStar(require("./formatUsername"), exports);

package/dist/esm/anyspend/react/components/common/OrderDetails.js

@@ -274,12 +274,7 @@ export const OrderDetails = memo(function OrderDetails({ mode = "modal", order,
         ? "0"
         : order.payload.expectedDstAmount.toString();
     const formattedExpectedDstAmount = formatTokenAmount(BigInt(expectedDstAmount), dstToken.decimals);
-    const actualDstAmount = order.type === "mint_nft" ||
-        order.type === "join_tournament" ||
-        order.type === "fund_tournament" ||
-        order.type === "custom"
-        ? undefined
-        : order.payload.actualDstAmount;
+    const actualDstAmount = order.settlement?.actualDstAmount;
     const formattedActualDstAmount = actualDstAmount
         ? formatTokenAmount(BigInt(actualDstAmount), dstToken.decimals)
         : undefined;

package/dist/esm/anyspend/react/components/common/OrderHistoryItem.js

@@ -10,12 +10,7 @@ export function OrderHistoryItem({ order, onSelectOrder, mode }) {
     const nft = order.type === "mint_nft" ? order.metadata.nft : undefined;
     const tournament = order.type === "join_tournament" || order.type === "fund_tournament" ? order.metadata.tournament : undefined;
     const dstToken = order.metadata.dstToken;
-    const actualDstAmount = order.type === "mint_nft" ||
-        order.type === "join_tournament" ||
-        order.type === "fund_tournament" ||
-        order.type === "custom"
-        ? undefined
-        : order.payload.actualDstAmount;
+    const actualDstAmount = order.settlement?.actualDstAmount;
     const expectedDstAmount = order.type === "mint_nft" ||
         order.type === "join_tournament" ||
         order.type === "fund_tournament" ||

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

@@ -36,6 +36,7 @@ export declare function useAnyspendFlow({ paymentType, recipientAddress, loadOrd
             relayTxs: components["schemas"]["RelayTx"][];
             executeTx: components["schemas"]["ExecuteTx"] | null;
             refundTxs: components["schemas"]["RefundTx"][];
+            points: number | null;
         };
         statusCode: number;
     } | undefined;

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

@@ -188,8 +188,8 @@ export function useAnyspendFlow({ paymentType = "crypto", recipientAddress, load
     // Handle order completion
     useEffect(() => {
         if (oat?.data?.order.status === "executed") {
-            // get the actualDstAmount if available from custompayload
-            const amount = oat.data.order.payload?.actualDstAmount;
+            // get the actualDstAmount if available from settlement
+            const amount = oat.data.order.settlement?.actualDstAmount;
             const formattedActualDstAmount = amount
                 ? formatTokenAmount(BigInt(amount), oat.data.order.metadata.dstToken.decimals)
                 : undefined;
@@ -197,7 +197,7 @@ export function useAnyspendFlow({ paymentType = "crypto", recipientAddress, load
         }
     }, [
         oat?.data?.order.status,
-        oat?.data?.order.payload,
+        oat?.data?.order.settlement?.actualDstAmount,
         onTransactionSuccess,
         oat?.data?.order.metadata.dstToken.decimals,
     ]);

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

@@ -8,6 +8,7 @@ export declare function useAnyspendOrderAndTransactions(orderId: string | undefi
             relayTxs: import("../..").components["schemas"]["RelayTx"][];
             executeTx: import("../..").components["schemas"]["ExecuteTx"] | null;
             refundTxs: import("../..").components["schemas"]["RefundTx"][];
+            points: number | null;
         };
         statusCode: number;
     } | undefined;
@@ -22,6 +23,7 @@ export declare function useAnyspendOrderAndTransactions(orderId: string | undefi
             relayTxs: import("../..").components["schemas"]["RelayTx"][];
             executeTx: import("../..").components["schemas"]["ExecuteTx"] | null;
             refundTxs: import("../..").components["schemas"]["RefundTx"][];
+            points: number | null;
         };
         statusCode: number;
     }, Error>>;