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

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

@@ -5,6 +5,7 @@ import { useEffect, useMemo, useState } from "react";
 import { viemAdapter } from "thirdweb/adapters/viem";
 import { useConnectedWallets, useWalletInfo } from "thirdweb/react";
 const debug = debugB3React("useFirstEOA");
+// Explicit return annotation keeps the hook's declaration portable (TS2742).
 export function useFirstEOA(chain) {
     const wallets = useConnectedWallets();
     const isConnected = useAuthStore(state => state.isConnected);

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

@@ -1,6 +1,6 @@
 import { toast } from "../../../global-account/react/index.js";
 import { PUBLIC_BASE_RPC_URL } from "../../../shared/constants/index.js";
-import { b3Mainnet, b3Testnet } from "../../../shared/constants/chains/supported.js";
+import { b3Mainnet, b3Testnet } from "../../../shared/constants/chains/b3Chain.js";
 import { formatNumber } from "../../../shared/utils/formatNumber.js";
 import { useQuery } from "@tanstack/react-query";
 import { createPublicClient, formatEther, formatUnits, http } from "viem";

package/dist/esm/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/esm/global-account/react/hooks/usePortfolioBalance.js

@@ -0,0 +1,72 @@
+import { useQuery } from "@tanstack/react-query";
+import { adaptZerionPositions, balanceMatchesToken, } from "../../../shared/utils/zerionPositions.js";
+/**
+ * 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 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.
+ */
+export function usePortfolioBalance(address, chainIds) {
+    const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+    return 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.
+ */
+export function usePortfolioTokenBalance(walletAddress, tokenAddress, chainId) {
+    return 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 && balanceMatchesToken(balance, tokenAddress ?? "")),
+    });
+}

package/dist/esm/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/esm/global-account/react/hooks/usePortfolioCollectibles.js

@@ -0,0 +1,175 @@
+import { zerionSlugToChainId } from "../../../shared/utils/zerionPositions.js";
+import { useQuery } from "@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.
+ */
+export function usePortfolioCollectibles(address, chainIds, options) {
+    const limit = options?.limit;
+    const filterSpam = options?.filterSpam;
+    const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+    return 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 = zerionSlugToChainId(nft.chain);
+                return chainId !== undefined && wantedChainIds.includes(chainId);
+            });
+            return nfts.length === all.length ? data : { ...data, nfts };
+        },
+    });
+}

package/dist/esm/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/esm/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/esm/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/esm/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/esm/global-account/react/hooks/useUnifiedChainSwitchAndExecute.js

@@ -8,18 +8,14 @@ import { useCallback, useState } from "react";
 import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdweb";
 import { isAddress } from "viem";
 import { useSwitchChain } from "wagmi";
-import { useB3Account } from "../components/B3Provider/useB3Account.js";
+import { useB3Config } from "../components/B3Provider/B3ConfigProvider.js";
 import { useAccountWallet } from "./useAccountWallet.js";
-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);
-invariant(partnerId, "Partner ID is required");
 export function useUnifiedChainSwitchAndExecute() {
     const { switchChainAsync } = useSwitchChain();
     const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = useState(false);
-    const { isActiveSmartWallet, isActiveEOAWallet, connectedEOAWallet } = useAccountWallet();
-    const aaAccount = useB3Account();
+    const { isActiveSmartWallet, isActiveEOAWallet, connectedSmartWallet, connectedEOAWallet } = useAccountWallet();
+    // From context, not process.env: partnerId is hashed into the server intent key and must match the ecosystem wallet.
+    const { partnerId } = useB3Config();
     // Handle EOA wallet chain switch and execute transaction
     const handleEOASwitchChainAndSendTransaction = useCallback(async (targetChainId, params) => {
         if (!connectedEOAWallet) {
@@ -96,10 +92,18 @@ export function useUnifiedChainSwitchAndExecute() {
             setIsSwitchingOrExecuting(false);
         }
     }, [connectedEOAWallet, switchChainAsync]);
-    // Handle AA wallet transaction (no chain switch needed for AA)
-    const handleAASendTransaction = useCallback(async (targetChainId, params) => {
-        if (!aaAccount) {
-            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 = useCallback(async (targetChainId, params, expectedGlobalAccountAddress) => {
+        const globalAccount = connectedSmartWallet?.getAccount();
+        if (!globalAccount) {
+            toast.error("Global Account not connected");
+            return;
+        }
+        if (expectedGlobalAccountAddress &&
+            globalAccount.address.toLowerCase() !== expectedGlobalAccountAddress.toLowerCase()) {
+            toast.error("Connected Global Account does not match the authenticated account");
             return;
         }
         try {
@@ -112,23 +116,28 @@ export function useUnifiedChainSwitchAndExecute() {
                 data: params.data,
                 value: params.value,
             });
-            // Check if we can use global-accounts-intents, if yes, create an intent.
-            try {
-                await app.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.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");
             }
             toast.info("Sending transaction…");
             const start = performance.now();
             const sendTxResponse = await twSendTransaction({
-                account: aaAccount,
+                account: globalAccount,
                 transaction,
             });
             const end = performance.now();
@@ -144,17 +153,18 @@ export function useUnifiedChainSwitchAndExecute() {
         finally {
             setIsSwitchingOrExecuting(false);
         }
-    }, [aaAccount]);
+    }, [connectedSmartWallet, partnerId]);
     // Unified switch chain and execute function
     const switchChainAndExecute = 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/esm/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/esm/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/esm/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/esm/notifications/services/api.js

@@ -1,4 +1,5 @@
 import { getAuthToken } from "../../shared/utils/auth-token.js";
+// Hardcoded default; consumers override via `B3Provider.notificationsApiUrl`.
 const DEFAULT_API_URL = "https://notifications.b3.fun";
 let apiUrl = DEFAULT_API_URL;
 export function setApiUrl(url) {

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

@@ -1,4 +1,3 @@
-import { ChainNetworks } from "../../../global-account/types/chain-networks";
 import { Chain as ThirdwebChain } from "thirdweb";
 import { Chain } from "viem";
 export declare const nullAddress = "0x0000000000000000000000000000000000000000";
@@ -33,17 +32,29 @@ export declare const b3Mainnet: {
     experimental_preconfirmationTime?: number | undefined | undefined;
     rpcUrls: {
         readonly default: {
-            readonly http: readonly ["https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"];
-            readonly ws: readonly ["wss://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"];
+            readonly http: readonly ["https://mainnet-rpc.b3.fun"];
+            readonly ws: readonly ["wss://mainnet-rpc.b3.fun/ws"];
         };
     };
     sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    readonly rpc: "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2";
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    readonly rpc: "https://mainnet-rpc.b3.fun";
     readonly icon: {
         readonly url: "https://cdn.b3.fun/b3_logo.svg";
         readonly width: 32;
@@ -51,55 +62,8 @@ export declare const b3Mainnet: {
         readonly format: "svg";
     };
 };
-export declare const getViemChainConfig: (config: ChainNetworks) => {
-    blockExplorers: {
-        readonly default: {
-            readonly name: string;
-            readonly url: string;
-        };
-    };
-    blockTime?: number | undefined | undefined;
-    contracts?: {
-        [x: string]: import("viem").ChainContract | {
-            [sourceId: number]: import("viem").ChainContract | undefined;
-        } | undefined;
-        ensRegistry?: import("viem").ChainContract | undefined;
-        ensUniversalResolver?: import("viem").ChainContract | undefined;
-        multicall3?: import("viem").ChainContract | undefined;
-        erc6492Verifier?: import("viem").ChainContract | undefined;
-    } | undefined;
-    ensTlds?: readonly string[] | undefined;
-    id: number;
-    name: string;
-    nativeCurrency: {
-        symbol: string;
-        name: string;
-        decimals: number;
-    };
-    experimental_preconfirmationTime?: number | undefined | undefined;
-    rpcUrls: {
-        readonly default: {
-            readonly http: readonly [string];
-            readonly ws: readonly [string];
-        };
-    };
-    sourceId?: number | undefined | undefined;
-    testnet: true | undefined;
-    custom?: Record<string, unknown> | undefined;
-    fees?: import("viem").ChainFees<undefined> | undefined;
-    formatters?: undefined;
-    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    readonly rpc: string;
-    readonly icon: {
-        format: string;
-        url: string;
-        width: number;
-        height: number;
-    };
-};
 export declare const thirdwebB3Testnet: ThirdwebChain;
 export declare const thirdwebB3Mainnet: ThirdwebChain;
-export declare const getThirdwebChainConfig: (config: ChainNetworks) => ThirdwebChain;
 export declare const b3Chain: Chain | {
     blockExplorers: {
         readonly default: {
@@ -128,17 +92,29 @@ export declare const b3Chain: Chain | {
     experimental_preconfirmationTime?: number | undefined | undefined;
     rpcUrls: {
         readonly default: {
-            readonly http: readonly ["https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"];
-            readonly ws: readonly ["wss://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"];
+            readonly http: readonly ["https://mainnet-rpc.b3.fun"];
+            readonly ws: readonly ["wss://mainnet-rpc.b3.fun/ws"];
         };
     };
     sourceId?: number | undefined | undefined;
+    supportsTransactionReplacementDetection?: boolean | undefined | undefined;
     testnet?: boolean | undefined | undefined;
     custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
     fees?: import("viem").ChainFees<undefined> | undefined;
     formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        client: import("viem").Client;
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
     serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
-    readonly rpc: "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2";
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    readonly rpc: "https://mainnet-rpc.b3.fun";
     readonly icon: {
         readonly url: "https://cdn.b3.fun/b3_logo.svg";
         readonly width: 32;