@b3dotfun/sdk 0.1.70-alpha.2 → 0.1.70-alpha.21

package/dist/cjs/global-account/react/hooks/useFirstEOA.js

@@ -8,6 +8,7 @@ const react_2 = require("react");
 const viem_1 = require("thirdweb/adapters/viem");
 const react_3 = require("thirdweb/react");
 const debug = (0, debug_1.debugB3React)("useFirstEOA");
+// Explicit return annotation keeps the hook's declaration portable (TS2742).
 function useFirstEOA(chain) {
     const wallets = (0, react_3.useConnectedWallets)();
     const isConnected = (0, react_1.useAuthStore)(state => state.isConnected);

package/dist/cjs/global-account/react/hooks/useNativeBalance.js

@@ -4,7 +4,7 @@ exports.useNativeBalance = useNativeBalance;
 exports.useNativeBalanceFromRPC = useNativeBalanceFromRPC;
 const react_1 = require("../../../global-account/react");
 const constants_1 = require("../../../shared/constants");
-const supported_1 = require("../../../shared/constants/chains/supported");
+const b3Chain_1 = require("../../../shared/constants/chains/b3Chain");
 const formatNumber_1 = require("../../../shared/utils/formatNumber");
 const react_query_1 = require("@tanstack/react-query");
 const viem_1 = require("viem");
@@ -90,7 +90,7 @@ function useNativeBalanceFromRPC(address, chainId) {
                 return 0;
             try {
                 const publicClient = (0, viem_1.createPublicClient)({
-                    chain: chainId === 8333 ? supported_1.b3Mainnet : supported_1.b3Testnet,
+                    chain: chainId === 8333 ? b3Chain_1.b3Mainnet : b3Chain_1.b3Testnet,
                     transport: (0, viem_1.http)(chainId === 8333 ? constants_1.PUBLIC_BASE_RPC_URL : undefined),
                 });
                 const balance = await publicClient.getBalance({

package/dist/cjs/global-account/react/hooks/usePortfolioBalance.d.ts

@@ -0,0 +1,15 @@
+import { type B3TokenBalance } from "../../../shared/utils/zerionPositions";
+/**
+ * Holdings for a wallet, optionally narrowed to specific chains.
+ *
+ * Read `isError` before reading `data`: a failed read and an empty wallet are different facts, and
+ * rendering the first as the second tells the user they hold nothing when nobody knows.
+ */
+export declare function usePortfolioBalance(address?: string, chainIds?: number[]): import("@tanstack/react-query").UseQueryResult<B3TokenBalance[], Error>;
+/**
+ * One token's balance for a wallet, served from the same per-wallet fetch as {@link usePortfolioBalance}.
+ *
+ * `tokenAddress` may be a contract address or the chain's native sentinel; matching is
+ * case-insensitive because callers pass addresses in whatever casing their source used.
+ */
+export declare function usePortfolioTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number): import("@tanstack/react-query").UseQueryResult<B3TokenBalance | undefined, Error>;

package/dist/cjs/global-account/react/hooks/usePortfolioBalance.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePortfolioBalance = usePortfolioBalance;
+exports.usePortfolioTokenBalance = usePortfolioTokenBalance;
+const react_query_1 = require("@tanstack/react-query");
+const zerionPositions_1 = require("../../../shared/utils/zerionPositions");
+/**
+ * Wallet holdings, read through the b3 portfolio proxy.
+ *
+ * The proxy holds the upstream API key server-side and authorizes browsers by Origin allowlist, so
+ * nothing secret ships to the client and no key is accepted from it. A consumer served from an
+ * origin the proxy does not know will be refused — adding an origin is a proxy config change, not
+ * an SDK change.
+ */
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+/**
+ * Fetch every spendable holding for a wallet in one request.
+ *
+ * Deliberately unpaginated and unfiltered by chain. The positions endpoint returns a wallet's full
+ * simple-position list in a single response, and passing a chain filter is actively harmful: the
+ * upstream rejects a handful of otherwise-valid chain slugs and fails the WHOLE request when one
+ * appears, so a caller asking for five chains can lose all five. Callers narrow the result instead.
+ */
+async function fetchWalletPositions(address) {
+    const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/positions/?filter[positions]=only_simple`;
+    const response = await fetch(url, { headers: { Accept: "application/json" } });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch wallet balances: ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    return (0, zerionPositions_1.adaptZerionPositions)(body.data ?? []);
+}
+/**
+ * Keyed by wallet alone so every consumer of the same wallet shares one fetch and one cache entry.
+ * Keying by the requested chain subset instead would refetch per caller and share nothing.
+ */
+function walletPositionsQueryKey(address) {
+    return ["walletPositions", address];
+}
+/**
+ * Holdings for a wallet, optionally narrowed to specific chains.
+ *
+ * Read `isError` before reading `data`: a failed read and an empty wallet are different facts, and
+ * rendering the first as the second tells the user they hold nothing when nobody knows.
+ */
+function usePortfolioBalance(address, chainIds) {
+    const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+    return (0, react_query_1.useQuery)({
+        queryKey: walletPositionsQueryKey(address),
+        queryFn: () => {
+            if (!address)
+                throw new Error("Address is required");
+            return fetchWalletPositions(address);
+        },
+        enabled: Boolean(address),
+        select: (balances) => wantedChainIds ? balances.filter(balance => wantedChainIds.includes(balance.chain_id)) : balances,
+    });
+}
+/**
+ * One token's balance for a wallet, served from the same per-wallet fetch as {@link usePortfolioBalance}.
+ *
+ * `tokenAddress` may be a contract address or the chain's native sentinel; matching is
+ * case-insensitive because callers pass addresses in whatever casing their source used.
+ */
+function usePortfolioTokenBalance(walletAddress, tokenAddress, chainId) {
+    return (0, react_query_1.useQuery)({
+        queryKey: walletPositionsQueryKey(walletAddress),
+        queryFn: () => {
+            if (!walletAddress)
+                throw new Error("Address is required");
+            return fetchWalletPositions(walletAddress);
+        },
+        enabled: Boolean(walletAddress) && Boolean(tokenAddress) && Boolean(chainId),
+        select: (balances) => balances.find(balance => balance.chain_id === chainId && (0, zerionPositions_1.balanceMatchesToken)(balance, tokenAddress ?? "")),
+    });
+}

package/dist/cjs/global-account/react/hooks/usePortfolioCollectibles.d.ts

@@ -0,0 +1,12 @@
+import type { SimpleHashNFTResponse } from "../../../global-account/types/simplehash.types";
+/**
+ * NFTs held by a wallet, in the SimpleHash shape `AccountAssets` already renders.
+ *
+ * Chain narrowing happens here rather than in the request: the upstream rejects some valid chain
+ * slugs outright and fails the whole request when one is present, so asking for a subset can cost
+ * you the whole answer.
+ */
+export declare function usePortfolioCollectibles(address?: string, chainIds?: number[], options?: {
+    limit?: number;
+    filterSpam?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<SimpleHashNFTResponse, Error>;

package/dist/cjs/global-account/react/hooks/usePortfolioCollectibles.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePortfolioCollectibles = usePortfolioCollectibles;
+const zerionPositions_1 = require("../../../shared/utils/zerionPositions");
+const react_query_1 = require("@tanstack/react-query");
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+/** Caps an ERC-1155 balance string at MAX_SAFE_INTEGER so a huge supply cannot overflow. */
+function safeParseBalance(balance) {
+    if (!balance)
+        return 1;
+    const parsed = parseInt(balance, 10);
+    if (Number.isNaN(parsed))
+        return 1;
+    return Math.min(parsed, Number.MAX_SAFE_INTEGER);
+}
+/**
+ * Reshape one Zerion NFT position into the SimpleHash record `AccountAssets` renders.
+ *
+ * Fields Zerion does not carry — traits, rarity, royalties, sale history — stay empty rather than
+ * being synthesised from something adjacent. In particular the position's `price` is a current
+ * estimate, not a sale, so it must not be written into `last_sale`.
+ */
+function toSimpleHashNft(position, ownerAddress) {
+    const attributes = position.attributes ?? {};
+    const nftInfo = attributes.nft_info;
+    const slug = position.relationships?.chain?.data?.id;
+    if (!nftInfo?.contract_address || !nftInfo.token_id || !slug)
+        return null;
+    const imageUrl = nftInfo.content?.detail?.url ?? nftInfo.content?.preview?.url ?? "";
+    const collectionInfo = attributes.collection_info ?? {};
+    const acquiredAt = attributes.changed_at ?? "";
+    return {
+        nft_id: `${slug}.${nftInfo.contract_address}.${nftInfo.token_id}`,
+        chain: slug,
+        contract_address: nftInfo.contract_address,
+        token_id: nftInfo.token_id,
+        name: nftInfo.name || "",
+        description: collectionInfo.description || "",
+        previews: {
+            image_small_url: nftInfo.content?.preview?.url ?? imageUrl,
+            image_medium_url: imageUrl,
+            image_large_url: imageUrl,
+            image_opengraph_url: imageUrl,
+            blurhash: "",
+            predominant_color: "",
+        },
+        image_url: imageUrl,
+        image_properties: { width: 0, height: 0, size: 0, mime_type: "", exif_orientation: null },
+        video_url: null,
+        video_properties: null,
+        audio_url: null,
+        audio_properties: null,
+        model_url: null,
+        model_properties: null,
+        other_url: null,
+        other_properties: null,
+        background_color: null,
+        external_url: null,
+        created_date: "",
+        status: "minted",
+        token_count: 1,
+        owner_count: 1,
+        owners: [
+            {
+                owner_address: ownerAddress,
+                quantity: safeParseBalance(attributes.amount),
+                quantity_string: attributes.amount || "1",
+                first_acquired_date: acquiredAt,
+                last_acquired_date: acquiredAt,
+            },
+        ],
+        contract: {
+            type: nftInfo.interface === "ERC1155" ? "ERC1155" : "ERC721",
+            name: collectionInfo.name || "",
+            symbol: null,
+            deployed_by: "",
+            deployed_via_contract: "",
+            owned_by: "",
+            has_multiple_collections: false,
+        },
+        collection: {
+            collection_id: nftInfo.contract_address,
+            name: collectionInfo.name || "Unknown Collection",
+            description: collectionInfo.description ?? null,
+            image_url: collectionInfo.content?.icon?.url ?? "",
+            image_properties: { width: 0, height: 0, mime_type: "" },
+            banner_image_url: null,
+            category: null,
+            is_nsfw: null,
+            external_url: null,
+            twitter_username: null,
+            discord_url: null,
+            instagram_username: null,
+            medium_username: null,
+            telegram_url: null,
+            marketplace_pages: [],
+            metaplex_mint: null,
+            metaplex_candy_machine: null,
+            metaplex_first_verified_creator: null,
+            floor_prices: [],
+            top_bids: [],
+            distinct_owner_count: 0,
+            distinct_nft_count: 0,
+            total_quantity: 0,
+            chains: [slug],
+            top_contracts: [nftInfo.contract_address],
+            collection_royalties: [],
+        },
+        last_sale: null,
+        primary_sale: null,
+        first_created: {
+            minted_to: ownerAddress,
+            quantity: 1,
+            quantity_string: "1",
+            timestamp: "",
+            block_number: 0,
+            transaction: "",
+            transaction_initiator: "",
+        },
+        rarity: { rank: null, score: null, unique_attributes: null },
+        royalty: [],
+        extra_metadata: {
+            attributes: [],
+            image_original_url: imageUrl,
+            animation_original_url: null,
+            metadata_original_url: "",
+        },
+    };
+}
+/**
+ * NFTs held by a wallet, in the SimpleHash shape `AccountAssets` already renders.
+ *
+ * Chain narrowing happens here rather than in the request: the upstream rejects some valid chain
+ * slugs outright and fails the whole request when one is present, so asking for a subset can cost
+ * you the whole answer.
+ */
+function usePortfolioCollectibles(address, chainIds, options) {
+    const limit = options?.limit;
+    const filterSpam = options?.filterSpam;
+    const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+    return (0, react_query_1.useQuery)({
+        queryKey: ["walletCollectibles", address, limit, filterSpam],
+        queryFn: async () => {
+            if (!address)
+                throw new Error("Address is required");
+            const params = new URLSearchParams();
+            if (limit)
+                params.set("page[size]", String(limit));
+            const query = params.toString();
+            const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/nft-positions/${query ? `?${query}` : ""}`;
+            const response = await fetch(url, { headers: { Accept: "application/json" } });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch collectibles: ${response.status} ${response.statusText}`);
+            }
+            const body = (await response.json());
+            // Spam is dropped here, not in `select`: the flag lives on the raw position and the
+            // SimpleHash shape has nowhere to carry it downstream.
+            const nfts = (body.data ?? [])
+                .filter(position => !(filterSpam && position.attributes?.nft_info?.flags?.is_spam === true))
+                .map(position => toSimpleHashNft(position, address))
+                .filter((nft) => nft !== null);
+            return { next_cursor: null, next: null, previous: null, nfts };
+        },
+        enabled: Boolean(address),
+        staleTime: 30 * 1000,
+        gcTime: 5 * 60 * 1000,
+        select: (data) => {
+            if (!wantedChainIds)
+                return data;
+            const all = data.nfts ?? [];
+            const nfts = all.filter(nft => {
+                const chainId = (0, zerionPositions_1.zerionSlugToChainId)(nft.chain);
+                return chainId !== undefined && wantedChainIds.includes(chainId);
+            });
+            return nfts.length === all.length ? data : { ...data, nfts };
+        },
+    });
+}

package/dist/cjs/global-account/react/hooks/useSiwe.d.ts

@@ -1,4 +1,4 @@
 import { Account } from "thirdweb/wallets";
 export declare function useSiwe(): {
-    authenticate: (account: Account, partnerId: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    authenticate: (account: Account, partnerId: string) => Promise<Record<string, any>>;
 };

package/dist/cjs/global-account/react/hooks/useSiwe.native.d.ts

@@ -1,4 +1,4 @@
 import { Account } from "thirdweb/wallets";
 export declare function useSiwe(): {
-    authenticate: (account: Account, partnerId: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    authenticate: (account: Account, partnerId: string) => Promise<Record<string, any>>;
 };

package/dist/cjs/global-account/react/hooks/useTWAuth.d.ts

@@ -3,5 +3,5 @@ import { Wallet } from "thirdweb/wallets";
  * @deprecated Use useAuth() instead
  */
 export declare function useTWAuth(): {
-    authenticate: (wallet: Wallet, partnerId: string) => Promise<import("@feathersjs/authentication").AuthenticationResult>;
+    authenticate: (wallet: Wallet, partnerId: string) => Promise<Record<string, any>>;
 };

package/dist/cjs/global-account/react/hooks/useUnifiedChainSwitchAndExecute.d.ts

@@ -5,6 +5,7 @@ export interface UnifiedTransactionParams {
 }
 export declare function useUnifiedChainSwitchAndExecute(): {
     switchChainAndExecute: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
+    switchChainAndExecuteWithGlobalAccount: (targetChainId: number, params: UnifiedTransactionParams, expectedGlobalAccountAddress?: string) => Promise<string | undefined>;
     switchChainAndExecuteWithEOA: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
     isSwitchingOrExecuting: boolean;
     isActiveSmartWallet: boolean | undefined;

package/dist/cjs/global-account/react/hooks/useUnifiedChainSwitchAndExecute.js

@@ -14,18 +14,14 @@ const react_2 = require("react");
 const thirdweb_2 = require("thirdweb");
 const viem_1 = require("viem");
 const wagmi_1 = require("wagmi");
-const useB3Account_1 = require("../components/B3Provider/useB3Account");
+const B3ConfigProvider_1 = require("../components/B3Provider/B3ConfigProvider");
 const useAccountWallet_1 = require("./useAccountWallet");
-const partnerId = String(process.env.PUBLIC_THIRDWEB_PARTNER_ID ||
-    process.env.NEXT_PUBLIC_THIRDWEB_PARTNER_ID ||
-    process.env.PUBLIC_GLOBAL_ACCOUNTS_PARTNER_ID ||
-    process.env.NEXT_PUBLIC_GLOBAL_ACCOUNTS_PARTNER_ID);
-(0, invariant_1.default)(partnerId, "Partner ID is required");
 function useUnifiedChainSwitchAndExecute() {
     const { switchChainAsync } = (0, wagmi_1.useSwitchChain)();
     const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = (0, react_2.useState)(false);
-    const { isActiveSmartWallet, isActiveEOAWallet, connectedEOAWallet } = (0, useAccountWallet_1.useAccountWallet)();
-    const aaAccount = (0, useB3Account_1.useB3Account)();
+    const { isActiveSmartWallet, isActiveEOAWallet, connectedSmartWallet, connectedEOAWallet } = (0, useAccountWallet_1.useAccountWallet)();
+    // From context, not process.env: partnerId is hashed into the server intent key and must match the ecosystem wallet.
+    const { partnerId } = (0, B3ConfigProvider_1.useB3Config)();
     // Handle EOA wallet chain switch and execute transaction
     const handleEOASwitchChainAndSendTransaction = (0, react_2.useCallback)(async (targetChainId, params) => {
         if (!connectedEOAWallet) {
@@ -102,10 +98,18 @@ function useUnifiedChainSwitchAndExecute() {
             setIsSwitchingOrExecuting(false);
         }
     }, [connectedEOAWallet, switchChainAsync]);
-    // Handle AA wallet transaction (no chain switch needed for AA)
-    const handleAASendTransaction = (0, react_2.useCallback)(async (targetChainId, params) => {
-        if (!aaAccount) {
-            react_1.toast.error("Smart wallet not connected");
+    // Handle Global Account transaction (no chain switch needed for AA).
+    // Resolve the signer from the connected ecosystem wallet rather than the active
+    // wallet so callers can explicitly require the Global Account.
+    const handleGlobalAccountSendTransaction = (0, react_2.useCallback)(async (targetChainId, params, expectedGlobalAccountAddress) => {
+        const globalAccount = connectedSmartWallet?.getAccount();
+        if (!globalAccount) {
+            react_1.toast.error("Global Account not connected");
+            return;
+        }
+        if (expectedGlobalAccountAddress &&
+            globalAccount.address.toLowerCase() !== expectedGlobalAccountAddress.toLowerCase()) {
+            react_1.toast.error("Connected Global Account does not match the authenticated account");
             return;
         }
         try {
@@ -118,23 +122,28 @@ function useUnifiedChainSwitchAndExecute() {
                 data: params.data,
                 value: params.value,
             });
-            // Check if we can use global-accounts-intents, if yes, create an intent.
-            try {
-                await app_1.default.service("global-accounts-intents").create({
-                    partnerId: partnerId,
-                    chainId: targetChainId,
-                    to: params.to,
-                    data: params.data || "0x",
-                    value: params.value.toString(),
-                });
+            // Pre-register an intent to authorize the signature server-side; skip if partnerId is missing.
+            if (partnerId) {
+                try {
+                    await app_1.default.service("global-accounts-intents").create({
+                        partnerId,
+                        chainId: targetChainId,
+                        to: params.to,
+                        data: params.data || "0x",
+                        value: params.value.toString(),
+                    });
+                }
+                catch (err) {
+                    console.error("Create global-accounts-intents error", err);
+                }
             }
-            catch (err) {
-                console.error("Create global-accounts-intents error", err);
+            else if (process.env.NODE_ENV !== "production") {
+                console.warn("useUnifiedChainSwitchAndExecute: missing partnerId from B3Config — skipping intent pre-authorization");
             }
             react_1.toast.info("Sending transaction…");
             const start = performance.now();
             const sendTxResponse = await (0, thirdweb_2.sendTransaction)({
-                account: aaAccount,
+                account: globalAccount,
                 transaction,
             });
             const end = performance.now();
@@ -150,17 +159,18 @@ function useUnifiedChainSwitchAndExecute() {
         finally {
             setIsSwitchingOrExecuting(false);
         }
-    }, [aaAccount]);
+    }, [connectedSmartWallet, partnerId]);
     // Unified switch chain and execute function
     const switchChainAndExecute = (0, react_2.useCallback)(async (targetChainId, params) => {
         // Check which wallet type is active
         if (isActiveSmartWallet) {
-            return handleAASendTransaction(targetChainId, params);
+            return handleGlobalAccountSendTransaction(targetChainId, params);
         }
         return handleEOASwitchChainAndSendTransaction(targetChainId, params);
-    }, [isActiveSmartWallet, handleAASendTransaction, handleEOASwitchChainAndSendTransaction]);
+    }, [isActiveSmartWallet, handleGlobalAccountSendTransaction, handleEOASwitchChainAndSendTransaction]);
     return {
         switchChainAndExecute,
+        switchChainAndExecuteWithGlobalAccount: handleGlobalAccountSendTransaction,
         switchChainAndExecuteWithEOA: handleEOASwitchChainAndSendTransaction,
         isSwitchingOrExecuting,
         isActiveSmartWallet,

package/dist/cjs/global-account/react/stores/useModalStore.d.ts

@@ -617,8 +617,16 @@ export interface AnySpendDepositModalProps extends BaseModalProps {
     destinationTokenAddress: string;
     /** The destination chain ID */
     destinationTokenChainId: number;
+    /**
+     * When false, the destination token is user-selectable even though a default destination token is
+     * provided (the provided destination is used only as the initial/default value). Used by the
+     * wallet-funding deposit flow so the user can change the receive token away from the default
+     * (Base USDC). Defaults to true (locked destination). Does not affect the QR/pure-transfer path. */
+    lockDestinationToken?: boolean;
     /** Callback when deposit succeeds */
     onSuccess?: (amount: string) => void;
+    /** Callback when the modal's close control is pressed. */
+    onClose?: () => void;
     /** Callback for opening a custom modal (e.g., for special token handling) */
     onOpenCustomModal?: () => void;
     /** Custom footer content */
@@ -641,8 +649,6 @@ export interface AnySpendDepositModalProps extends BaseModalProps {
     showChainSelection?: boolean;
     /** Whether to show the "Fund with Fiat" option in the deposit options list. Defaults to true */
     showFiatOption?: boolean;
-    /** Minimum pool size for filtering tokens (default: 1,000,000) */
-    minPoolSize?: number;
     /** Custom title for chain selection step */
     chainSelectionTitle?: string;
     /** Custom description for chain selection step */
@@ -661,6 +667,12 @@ export interface AnySpendDepositModalProps extends BaseModalProps {
     classes?: AnySpendAllClasses;
     /** Whether to allow direct transfer without swap */
     allowDirectTransfer?: boolean;
+    /**
+     * When true, the QR-deposit path is a PURE TRANSFER: the destination token/chain
+     * mirror the user's selected source token, so the exact token they send lands in
+     * their wallet on the same chain (no swap/bridge).
+     */
+    pureTransferOnly?: boolean;
     /** Opaque metadata passed to the order for callbacks (e.g., workflow form data) */
     callbackMetadata?: Record<string, unknown>;
 }

package/dist/cjs/global-account/types/b3-api.types.d.ts

@@ -3,9 +3,13 @@
  */
 type ObjectId = string;
 interface PartnerIds {
+    /** @deprecated Privy is no longer used for authentication. This field exists for legacy data compatibility only. */
     privyId?: string;
     thirdwebId?: string;
 }
+/**
+ * @deprecated Privy is no longer used for authentication. This type exists for legacy data compatibility only.
+ */
 interface PrivyLinkedAccount {
     type: string;
     address?: string;
@@ -45,6 +49,7 @@ interface User {
     createdAt: number;
     updatedAt: number;
     partnerIds: PartnerIds;
+    /** @deprecated Privy is no longer used for authentication. This field exists for legacy data compatibility only. */
     privyLinkedAccounts?: PrivyLinkedAccount[];
     twProfiles?: TWProfile[];
 }

package/dist/cjs/global-account/types/feature-flags.d.ts

@@ -1,8 +1,8 @@
 import { Static } from "@feathersjs/typebox";
-export declare const featureFlagsSchema: import("@feathersjs/typebox").TObject<{
-    _id: import("@feathersjs/typebox").TUnion<[import("@feathersjs/typebox").TString<string>, import("@feathersjs/typebox").TObject<{}>]>;
-    id: import("@feathersjs/typebox").TString<string>;
-    enabled: import("@feathersjs/typebox").TBoolean;
-    description: import("@feathersjs/typebox").TString<string>;
+export declare const featureFlagsSchema: import("@sinclair/typebox").TObject<{
+    _id: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString<string>, import("@sinclair/typebox").TObject<{}>]>;
+    id: import("@sinclair/typebox").TString<string>;
+    enabled: import("@sinclair/typebox").TBoolean;
+    description: import("@sinclair/typebox").TString<string>;
 }>;
 export type FeatureFlags = Static<typeof featureFlagsSchema>;

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

@@ -4,6 +4,7 @@ exports.notificationsAPI = void 0;
 exports.setApiUrl = setApiUrl;
 exports.getApiUrl = getApiUrl;
 const auth_token_1 = require("../../shared/utils/auth-token");
+// Hardcoded default; consumers override via `B3Provider.notificationsApiUrl`.
 const DEFAULT_API_URL = "https://notifications.b3.fun";
 let apiUrl = DEFAULT_API_URL;
 function setApiUrl(url) {