@b3dotfun/sdk 0.0.73-test.3 → 0.0.74-alpha.0

package/dist/esm/global-account/react/stores/useRecentAddressesStore.d.ts

@@ -0,0 +1,25 @@
+interface RecentAddress {
+    address: string;
+    timestamp: number;
+}
+interface RecentAddressesStore {
+    recentAddresses: RecentAddress[];
+    addRecentAddress: (address: string) => void;
+    clearRecentAddresses: () => void;
+}
+/**
+ * Store for managing recently used addresses in the Send flow
+ * Persists to localStorage and keeps the last 6 unique addresses
+ */
+export declare const useRecentAddressesStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<RecentAddressesStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<RecentAddressesStore, RecentAddressesStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: RecentAddressesStore) => void) => () => void;
+        onFinishHydration: (fn: (state: RecentAddressesStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<RecentAddressesStore, RecentAddressesStore>>;
+    };
+}>;
+export {};

package/dist/esm/global-account/react/stores/useRecentAddressesStore.js

@@ -0,0 +1,33 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+/**
+ * Store for managing recently used addresses in the Send flow
+ * Persists to localStorage and keeps the last 6 unique addresses
+ */
+export const useRecentAddressesStore = create()(persist(set => ({
+    recentAddresses: [],
+    /**
+     * Add a new address to the recent addresses list
+     * Deduplicates and maintains a maximum of 6 addresses
+     */
+    addRecentAddress: (address) => {
+        set(state => {
+            // Remove any existing entry with the same address
+            const filtered = state.recentAddresses.filter(item => item.address.toLowerCase() !== address.toLowerCase());
+            // Add the new address at the beginning
+            const updated = [{ address, timestamp: Date.now() }, ...filtered];
+            // Keep only the last 6 addresses
+            return {
+                recentAddresses: updated.slice(0, 6),
+            };
+        });
+    },
+    /**
+     * Clear all recent addresses
+     */
+    clearRecentAddresses: () => {
+        set({ recentAddresses: [] });
+    },
+}), {
+    name: "b3-recent-addresses-storage",
+}));

package/dist/esm/global-account/react/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./notificationsAPI";
+export * from "./profileDisplay";
+export * from "./toast";
+export * from "./updateAvatar";

package/dist/esm/global-account/react/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./notificationsAPI.js";
+export * from "./profileDisplay.js";
+export * from "./toast.js";
+export * from "./updateAvatar.js";

package/dist/esm/global-account/react/utils/notificationsAPI.d.ts

@@ -0,0 +1,80 @@
+export interface NotificationChannel {
+    id: number;
+    channel_type: "email" | "telegram" | "discord" | "sms" | "whatsapp" | "in_app";
+    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 NotificationSettings {
+    notificationType: string;
+    channels: string[];
+}
+export declare const notificationsAPI: {
+    /**
+     * Register user (requires JWT)
+     */
+    registerUser(jwtToken: string): Promise<UserData>;
+    /**
+     * Get user data (requires JWT)
+     */
+    getUser(userId: string, jwtToken: string): Promise<UserData>;
+    /**
+     * Connect email (requires JWT)
+     */
+    connectEmail(userId: string, email: string, jwtToken: string): Promise<any>;
+    /**
+     * Connect SMS (requires JWT)
+     */
+    connectSMS(userId: string, phoneNumber: string, jwtToken: string): Promise<any>;
+    /**
+     * Connect WhatsApp (requires JWT)
+     */
+    connectWhatsApp(userId: string, phoneNumber: string, jwtToken: string): Promise<any>;
+    /**
+     * Connect Discord (requires JWT)
+     */
+    connectDiscord(userId: string, discordUserId: string, jwtToken: string): Promise<any>;
+    /**
+     * Disconnect a channel (requires JWT)
+     * Looks up the channel ID by type and deletes it
+     */
+    disconnectChannel(userId: string, channelType: string, jwtToken: string): Promise<any>;
+    /**
+     * Get Telegram deep link (requires JWT)
+     */
+    getTelegramLink(jwtToken: string): Promise<{
+        deepLink: string;
+    }>;
+    /**
+     * Check Telegram status (requires JWT)
+     */
+    checkTelegramStatus(userId: string, jwtToken: string): Promise<{
+        connected: boolean;
+    }>;
+    /**
+     * Save notification preferences (requires JWT)
+     */
+    savePreferences(userId: string, appId: string, settings: NotificationSettings, jwtToken: string): Promise<any>;
+    /**
+     * Ensure notification settings exist for a user/app/type combination
+     * Creates default settings if they don't exist
+     */
+    ensureNotificationSettings(userId: string, appId: string, notificationType: string, jwtToken: string): Promise<any>;
+    /**
+     * Send a test notification (requires JWT)
+     * Automatically creates settings if they don't exist
+     */
+    sendTestNotification(userId: string, appId: string, jwtToken: string): Promise<any>;
+};

package/dist/esm/global-account/react/utils/notificationsAPI.js

@@ -0,0 +1,254 @@
+import { debugB3React } from "../../../shared/utils/debug.js";
+const debug = debugB3React("notificationsAPI");
+const API_URL = "https://notifications.b3.fun";
+export const notificationsAPI = {
+    /**
+     * Register user (requires JWT)
+     */
+    async registerUser(jwtToken) {
+        const res = await fetch(`${API_URL}/users`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to register user: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Get user data (requires JWT)
+     */
+    async getUser(userId, jwtToken) {
+        const res = await fetch(`${API_URL}/users/${userId}`, {
+            headers: {
+                Authorization: `Bearer ${jwtToken}`,
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to get user: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Connect email (requires JWT)
+     */
+    async connectEmail(userId, email, jwtToken) {
+        const res = await fetch(`${API_URL}/users/${userId}/channels`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                channelType: "email",
+                channelIdentifier: email,
+                enabled: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to connect email: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Connect SMS (requires JWT)
+     */
+    async connectSMS(userId, phoneNumber, jwtToken) {
+        const res = await fetch(`${API_URL}/users/${userId}/channels`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                channelType: "sms",
+                channelIdentifier: phoneNumber,
+                enabled: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to connect SMS: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Connect WhatsApp (requires JWT)
+     */
+    async connectWhatsApp(userId, phoneNumber, jwtToken) {
+        const res = await fetch(`${API_URL}/users/${userId}/channels`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                channelType: "whatsapp",
+                channelIdentifier: phoneNumber,
+                enabled: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to connect WhatsApp: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Connect Discord (requires JWT)
+     */
+    async connectDiscord(userId, discordUserId, jwtToken) {
+        const res = await fetch(`${API_URL}/users/${userId}/channels`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                channelType: "discord",
+                channelIdentifier: discordUserId,
+                enabled: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to connect Discord: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Disconnect a channel (requires JWT)
+     * Looks up the channel ID by type and deletes it
+     */
+    async disconnectChannel(userId, channelType, jwtToken) {
+        // First, get user data to find the channel ID
+        const userData = await this.getUser(userId, jwtToken);
+        const channel = userData.channels.find((c) => c.channel_type === channelType);
+        if (!channel) {
+            throw new Error(`Channel ${channelType} not found`);
+        }
+        // Delete using the channel ID
+        const res = await fetch(`${API_URL}/users/${userId}/channels/${channel.id}`, {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${jwtToken}`,
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to disconnect channel: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Get Telegram deep link (requires JWT)
+     */
+    async getTelegramLink(jwtToken) {
+        const res = await fetch(`${API_URL}/telegram/request-link`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to get Telegram link: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Check Telegram status (requires JWT)
+     */
+    async checkTelegramStatus(userId, jwtToken) {
+        const res = await fetch(`${API_URL}/telegram/status/${userId}`, {
+            headers: {
+                Authorization: `Bearer ${jwtToken}`,
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to check Telegram status: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Save notification preferences (requires JWT)
+     */
+    async savePreferences(userId, appId, settings, jwtToken) {
+        const res = await fetch(`${API_URL}/users/${userId}/apps/${appId}/settings`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                ...settings,
+                enabled: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to save preferences: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Ensure notification settings exist for a user/app/type combination
+     * Creates default settings if they don't exist
+     */
+    async ensureNotificationSettings(userId, appId, notificationType, jwtToken) {
+        // Get user's connected channels
+        const userData = await this.getUser(userId, jwtToken);
+        const enabledChannels = userData.channels
+            .filter((c) => c.enabled === 1)
+            .map((c) => c.channel_type);
+        if (enabledChannels.length === 0) {
+            throw new Error("No channels connected");
+        }
+        // Create settings with all enabled channels
+        const res = await fetch(`${API_URL}/users/${userId}/apps/${appId}/settings`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                notificationType,
+                channels: enabledChannels,
+                enabled: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to create notification settings: ${res.statusText}`);
+        }
+        return res.json();
+    },
+    /**
+     * Send a test notification (requires JWT)
+     * Automatically creates settings if they don't exist
+     */
+    async sendTestNotification(userId, appId, jwtToken) {
+        // Ensure settings exist for test notifications
+        try {
+            await this.ensureNotificationSettings(userId, appId, "general", jwtToken);
+        }
+        catch (err) {
+            debug("Failed to ensure settings, trying to send anyway:", err);
+        }
+        const res = await fetch(`${API_URL}/send`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${jwtToken}`,
+            },
+            body: JSON.stringify({
+                userId,
+                appId,
+                notificationType: "general",
+                title: "Test Notification",
+                message: "This is a test notification from B3. If you received this, your notifications are working correctly! 🎉",
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to send test notification: ${res.statusText}`);
+        }
+        return res.json();
+    },
+};

package/dist/esm/global-account/react/utils/profileDisplay.d.ts

@@ -6,6 +6,7 @@ import { type Profile } from "thirdweb/wallets";
  */
 export declare function validateImageUrl(url: string | null | undefined): string | null;
 export interface ExtendedProfileDetails {
+    fid?: string;
     id?: string;
     email?: string;
     phone?: string;
@@ -13,6 +14,8 @@ export interface ExtendedProfileDetails {
     name?: string;
     username?: string;
     profileImageUrl?: string;
+    picture?: string;
+    pfpUrl?: string;
 }
 export interface ExtendedProfile extends Omit<Profile, "details"> {
     details: ExtendedProfileDetails;

package/dist/esm/global-account/react/utils/profileDisplay.js

@@ -54,7 +54,11 @@ export function validateImageUrl(url) {
     }
 }
 export function getProfileDisplayInfo(profile) {
-    const { type, details } = profile;
+    const { type: originalType, details } = profile;
+    let type = originalType;
+    if (originalType === "siwe") {
+        type = "EOA";
+    }
     // Default display info
     let displayInfo = {
         title: details.email || details.phone || details.address || "Unknown",
@@ -76,9 +80,9 @@ export function getProfileDisplayInfo(profile) {
             break;
         case "farcaster":
             displayInfo = {
-                title: details.name || details.username || "Unknown",
+                title: details.name || details.username || "FID:" + details?.fid || "Unknown",
                 subtitle: details.username ? `@${details.username}` : "Farcaster Account",
-                imageUrl: validateImageUrl(details.profileImageUrl),
+                imageUrl: validateImageUrl(details.pfpUrl || details.profileImageUrl),
                 initial: "F",
                 type,
             };
@@ -87,7 +91,7 @@ export function getProfileDisplayInfo(profile) {
             displayInfo = {
                 title: details.name || details.email || "Unknown",
                 subtitle: details.email || "Google Account",
-                imageUrl: validateImageUrl(details.profileImageUrl),
+                imageUrl: validateImageUrl(details.picture || details.profileImageUrl),
                 initial: "G",
                 type,
             };

package/dist/esm/global-account/react/utils/toast.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export toast utilities for easy import
+ * This allows components to import toast from a central location
+ */
+export { toast } from "../components/Toast/toastApi";
+export type { ToastItem, ToastType } from "../components/Toast/ToastContext";

package/dist/esm/global-account/react/utils/toast.js

@@ -0,0 +1,5 @@
+/**
+ * Re-export toast utilities for easy import
+ * This allows components to import toast from a central location
+ */
+export { toast } from "../components/Toast/toastApi.js";

package/dist/esm/shared/constants/chains/supported.d.ts

@@ -53,10 +53,10 @@ export declare function getCoingeckoChainInfo(chainId: number): {
     name: string;
     native_coin_id: string;
 };
-export declare const b3MainnetThirdWeb: Readonly<import("thirdweb/dist/types/chains/types").ChainOptions & {
+export declare const b3MainnetThirdWeb: Readonly<import("thirdweb/chains").ChainOptions & {
     rpc: string;
 }>;
-export declare const b3TestnetThirdWeb: Readonly<import("thirdweb/dist/types/chains/types").ChainOptions & {
+export declare const b3TestnetThirdWeb: Readonly<import("thirdweb/chains").ChainOptions & {
     rpc: string;
 }>;
 export declare const b3Mainnet: import("viem").Chain;
@@ -66,3 +66,4 @@ export declare const baseMainnet: import("viem").Chain;
  * Get a Thirdweb chain by chain ID from supportedChainsTW
  */
 export declare function getThirdwebChain(chainId: number): ThirdwebChain;
+export declare function getChainLogo(chainId: number): string;

package/dist/esm/shared/constants/chains/supported.js

@@ -55,3 +55,6 @@ export function getThirdwebChain(chainId) {
     }
     return chain;
 }
+export function getChainLogo(chainId) {
+    return getThirdwebChain(chainId)?.icon?.url || "";
+}

package/dist/esm/shared/utils/ipfs.js

@@ -1,7 +1,14 @@
+/**
+ * List of IPFS gateways to use for converting ipfs:// URLs to HTTP URLs
+ * These gateways must match the allowed list in profileDisplay.ts validateImageUrl()
+ */
 const IPFS_GATEWAYS = [
-    "https://ipfs.io/ipfs",
-    "https://cloudflare-ipfs.com/ipfs",
-    // Can add more gateways as needed
+    "https://cloudflare-ipfs.com/ipfs", // Primary gateway - fast and reliable
+    "https://ipfs.io/ipfs", // Fallback gateway
+    "https://gateway.pinata.cloud/ipfs", // Additional option
+    "https://dweb.link/ipfs", // Additional option
+    "https://nftstorage.link/ipfs", // Additional option
+    "https://w3s.link/ipfs", // Additional option
 ];
 /**
  * Converts an IPFS URL to a gateway URL