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

package/src/global-account/react/hooks/usePortfolioCollectibles.ts

@@ -0,0 +1,212 @@
+import type { NFT, SimpleHashNFTResponse } from "@b3dotfun/sdk/global-account/types/simplehash.types";
+import { zerionSlugToChainId } from "@b3dotfun/sdk/shared/utils/zerionPositions";
+import { useQuery } from "@tanstack/react-query";
+
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+
+interface ZerionNftPosition {
+  id?: string;
+  attributes?: {
+    amount?: string;
+    changed_at?: string;
+    nft_info?: {
+      contract_address?: string;
+      token_id?: string;
+      name?: string;
+      interface?: string;
+      content?: { preview?: { url?: string }; detail?: { url?: string } };
+      flags?: { is_spam?: boolean };
+    };
+    collection_info?: {
+      name?: string;
+      description?: string;
+      content?: { icon?: { url?: string } };
+    };
+  };
+  relationships?: { chain?: { data?: { id?: string } } };
+}
+
+interface ZerionNftPositionsResponse {
+  data?: ZerionNftPosition[];
+}
+
+/** Caps an ERC-1155 balance string at MAX_SAFE_INTEGER so a huge supply cannot overflow. */
+function safeParseBalance(balance: string | undefined): number {
+  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: ZerionNftPosition, ownerAddress: string): NFT | null {
+  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?: string,
+  chainIds?: number[],
+  options?: { limit?: number; filterSpam?: boolean },
+) {
+  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 (): Promise<SimpleHashNFTResponse> => {
+      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()) as ZerionNftPositionsResponse;
+      // 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 is NFT => nft !== null);
+
+      return { next_cursor: null, next: null, previous: null, nfts };
+    },
+    enabled: Boolean(address),
+    staleTime: 30 * 1000,
+    gcTime: 5 * 60 * 1000,
+    select: (data: SimpleHashNFTResponse) => {
+      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/src/global-account/react/hooks/useSiwe.native.tsx

@@ -4,7 +4,7 @@ import { useCallback } from "react";
 import { Account } from "thirdweb/wallets";
 
 export function useSiwe() {
-  const authenticate = useCallback(async (account: Account, partnerId: string) => {
+  const authenticate = useCallback(async (account: Account, partnerId: string): Promise<Record<string, any>> => {
     if (!account || !account.signMessage) throw new Error("Account not found");
     // generate challenge
     const challenge = await app.service("global-accounts-challenge").create({

package/src/global-account/react/hooks/useSiwe.tsx

@@ -8,7 +8,7 @@ export function useSiwe() {
   const referralCode = useSearchParam("referralCode");
 
   const authenticate = useCallback(
-    async (account: Account, partnerId: string) => {
+    async (account: Account, partnerId: string): Promise<Record<string, any>> => {
       console.warn("@@useSiwe is deprecated, use useTWAuth instead");
       if (!account || !account.signMessage) throw new Error("Account not found");
 

package/src/global-account/react/hooks/useTWAuth.tsx

@@ -15,7 +15,7 @@ export function useTWAuth() {
   const referralCode = useSearchParam("referralCode");
 
   const authenticate = useCallback(
-    async (wallet: Wallet, partnerId: string) => {
+    async (wallet: Wallet, partnerId: string): Promise<Record<string, any>> => {
       if (!wallet || !wallet?.getAuthToken?.()) throw new Error("Wallet not found");
 
       const authToken = wallet.getAuthToken();

package/src/global-account/react/hooks/useUnifiedChainSwitchAndExecute.ts

@@ -9,7 +9,7 @@ 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";
+import { useB3Config } from "../components/B3Provider/B3ConfigProvider";
 import { useAccountWallet } from "./useAccountWallet";
 
 export interface UnifiedTransactionParams {
@@ -18,20 +18,14 @@ export interface UnifiedTransactionParams {
   value: bigint;
 }
 
-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(
@@ -123,11 +117,26 @@ export function useUnifiedChainSwitchAndExecute() {
     [connectedEOAWallet, switchChainAsync],
   );
 
-  // Handle AA wallet transaction (no chain switch needed for AA)
-  const handleAASendTransaction = useCallback(
-    async (targetChainId: number, params: UnifiedTransactionParams): Promise<string | undefined> => {
-      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: number,
+      params: UnifiedTransactionParams,
+      expectedGlobalAccountAddress?: string,
+    ): Promise<string | undefined> => {
+      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;
       }
 
@@ -144,23 +153,29 @@ export function useUnifiedChainSwitchAndExecute() {
           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(),
-          });
-        } catch (err: any) {
-          console.error("Create global-accounts-intents error", err);
+        // 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: any) {
+            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();
@@ -176,7 +191,7 @@ export function useUnifiedChainSwitchAndExecute() {
         setIsSwitchingOrExecuting(false);
       }
     },
-    [aaAccount],
+    [connectedSmartWallet, partnerId],
   );
 
   // Unified switch chain and execute function
@@ -184,15 +199,16 @@ export function useUnifiedChainSwitchAndExecute() {
     async (targetChainId: number, params: UnifiedTransactionParams): Promise<string | undefined> => {
       // 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/src/global-account/react/stores/useModalStore.ts

@@ -645,8 +645,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 */
@@ -667,8 +675,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 */
@@ -687,6 +693,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/src/global-account/types/b3-api.types.ts

@@ -10,11 +10,14 @@ type ObjectId = string;
 
 // Partner IDs interface
 interface PartnerIds {
+  /** @deprecated Privy is no longer used for authentication. This field exists for legacy data compatibility only. */
   privyId?: string;
   thirdwebId?: string;
 }
 
-// Privy linked account interface
+/**
+ * @deprecated Privy is no longer used for authentication. This type exists for legacy data compatibility only.
+ */
 interface PrivyLinkedAccount {
   type: string; // "wallet" | "smart_wallet" | "google_oauth"
   address?: string;
@@ -76,6 +79,7 @@ interface User {
 
   // Partner integrations
   partnerIds: PartnerIds;
+  /** @deprecated Privy is no longer used for authentication. This field exists for legacy data compatibility only. */
   privyLinkedAccounts?: PrivyLinkedAccount[];
   twProfiles?: TWProfile[];
 }

package/src/notifications/services/api.ts

@@ -8,6 +8,7 @@ import type {
   UserData,
 } from "../types";
 
+// Hardcoded default; consumers override via `B3Provider.notificationsApiUrl`.
 const DEFAULT_API_URL = "https://notifications.b3.fun";
 
 let apiUrl: string = DEFAULT_API_URL;

package/src/shared/constants/chains/b3Chain.ts

@@ -1,4 +1,3 @@
-import { ChainNetworks } from "@b3dotfun/sdk/global-account/types/chain-networks";
 import { defineChain as defineThirdwebChain, Chain as ThirdwebChain } from "thirdweb";
 import { Chain, defineChain } from "viem";
 
@@ -58,11 +57,11 @@ export const b3Testnet: Chain = defineChain({
 export const b3Mainnet = defineChain({
   id: 8333,
   name: "B3",
-  rpc: "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2",
+  rpc: "https://mainnet-rpc.b3.fun",
   rpcUrls: {
     default: {
-      http: ["https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"],
-      ws: ["wss://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"],
+      http: ["https://mainnet-rpc.b3.fun"],
+      ws: ["wss://mainnet-rpc.b3.fun/ws"],
     },
   },
   icon: {
@@ -84,28 +83,6 @@ export const b3Mainnet = defineChain({
   },
 });
 
-export const getViemChainConfig = (config: ChainNetworks) =>
-  defineChain({
-    id: config.id,
-    name: config.name,
-    rpc: config.rpcUrls.default.http,
-    rpcUrls: {
-      default: {
-        http: [config.rpcUrls.default.http],
-        ws: [config.rpcUrls.default.ws],
-      },
-    },
-    icon: config.icon,
-    blockExplorers: {
-      default: {
-        name: config.blockExplorers.explorerTitle,
-        url: config.blockExplorers.default,
-      },
-    },
-    nativeCurrency: config.nativeCurrency,
-    testnet: config.testnet ? true : undefined,
-  });
-
 export const thirdwebB3Testnet: ThirdwebChain = defineThirdwebChain({
   id: 1993,
   name: "B3 Sepolia",
@@ -133,7 +110,7 @@ export const thirdwebB3Testnet: ThirdwebChain = defineThirdwebChain({
 export const thirdwebB3Mainnet: ThirdwebChain = defineThirdwebChain({
   id: 8333,
   name: "B3",
-  rpc: "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2/",
+  rpc: "https://mainnet-rpc.b3.fun",
   icon: {
     url: "https://cdn.b3.fun/b3_logo.svg",
     width: 32,
@@ -153,22 +130,6 @@ export const thirdwebB3Mainnet: ThirdwebChain = defineThirdwebChain({
   },
 });
 
-export const getThirdwebChainConfig = (config: ChainNetworks): ThirdwebChain =>
-  defineThirdwebChain({
-    id: config.id,
-    name: config.name,
-    rpc: config.rpcUrls.default.http,
-    icon: config.icon,
-    blockExplorers: [
-      {
-        name: config.blockExplorers.explorerTitle,
-        url: config.blockExplorers.default,
-      },
-    ],
-    nativeCurrency: config.nativeCurrency,
-    testnet: config.testnet ? true : undefined,
-  });
-
 export const b3Chain = process.env.NEXT_PUBLIC_B3_CHAINID === "8333" ? b3Mainnet : b3Testnet;
 export const thirdwebB3Chain: ThirdwebChain =
   process.env.NEXT_PUBLIC_B3_CHAINID === "8333" ? thirdwebB3Mainnet : thirdwebB3Testnet;

package/src/shared/constants/chains/supported.ts

@@ -1,75 +1,36 @@
-import type { ChainNetworks } from "@b3dotfun/sdk/global-account/types/chain-networks";
+import { ANYSPEND_EVM_CHAINS } from "@b3/chain-registry/runtime";
 import { toThirdwebChain, toViemChain } from "@b3dotfun/sdk/shared/utils/chain-transformers";
 import invariant from "invariant";
-
 import type { Chain as ThirdwebChain } from "thirdweb";
-// Import the JSON directly
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import chainNetworksJSON from "../../generated/chain-networks.json" with { type: "json" };
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import coingeckoChainsJSON from "../../generated/coingecko-chains.json" with { type: "json" };
 
-const chainNetworks = chainNetworksJSON as ChainNetworks[];
-
-// Convert custom chains to Viem format
-const viemChains = chainNetworks.map(toViemChain);
-
-// TODO: link to doc explaining why we don't support all chains and how to add more
-// These are the chains that are supported for things such as bridging and fetching balances
-export const supportedChains = [...viemChains];
-
-// ThirdWeb format chains
-export const supportedChainsTW: ThirdwebChain[] = [
-  ...chainNetworks
-    .map(chain => {
-      const networkData = chainNetworks.find(n => n.id === chain.id);
-      return networkData ? toThirdwebChain(networkData) : undefined;
-    })
-    .filter((chain): chain is NonNullable<typeof chain> => chain !== undefined),
-];
+export const supportedChains = ANYSPEND_EVM_CHAINS.map(toViemChain);
+export const supportedChainsTW: ThirdwebChain[] = ANYSPEND_EVM_CHAINS.map(toThirdwebChain);
+export const supportedChainNetworks = ANYSPEND_EVM_CHAINS;
 
-// Original format from chain-networks.json
-export const supportedChainNetworks = chainNetworks;
-
-// CoinGecko chain mapping
 export const coingeckoChains = coingeckoChainsJSON as Record<
   number,
-  {
-    coingecko_id: string;
-    name: string;
-    native_coin_id: string;
-  }
+  { coingecko_id: string; name: string; native_coin_id: string }
 >;
-// Helper function to get CoinGecko chain info
+
 export function getCoingeckoChainInfo(chainId: number) {
   return coingeckoChains[chainId];
 }
 
-const _b3MainnetThirdWeb: ThirdwebChain | undefined = supportedChainsTW.find(chain => chain.id === 8333);
+const _b3MainnetThirdWeb = supportedChainsTW.find(c => c.id === 8333);
 invariant(_b3MainnetThirdWeb, "B3 mainnet chain not found in supported chains TW");
 export const b3MainnetThirdWeb = _b3MainnetThirdWeb;
 
-const _b3TestnetThirdWeb: ThirdwebChain | undefined = supportedChainsTW.find(chain => chain.id === 1993);
-invariant(_b3TestnetThirdWeb, "B3 testnet chain not found in supported chains TW");
-export const b3TestnetThirdWeb = _b3TestnetThirdWeb;
-
-const _b3Mainnet = supportedChains.find(chain => chain.id === 8333);
+const _b3Mainnet = supportedChains.find(c => c.id === 8333);
 invariant(_b3Mainnet, "B3 mainnet chain not found in supported chains");
 export const b3Mainnet = _b3Mainnet;
 
-const _b3Testnet = supportedChains.find(chain => chain.id === 1993);
-invariant(_b3Testnet, "B3 testnet chain not found in supported chains");
-export const b3Testnet = _b3Testnet;
-
-const _baseMainnet = supportedChains.find(chain => chain.id === 8453);
+const _baseMainnet = supportedChains.find(c => c.id === 8453);
 invariant(_baseMainnet, "Base mainnet chain not found in supported chains");
 export const baseMainnet = _baseMainnet;
 
-/**
- * Get a Thirdweb chain by chain ID from supportedChainsTW
- */
 export function getThirdwebChain(chainId: number): ThirdwebChain {
   const chain = supportedChainsTW.find(c => c.id === chainId);
   if (!chain) {

package/src/shared/constants/index.ts

@@ -1,3 +1,5 @@
+import type { Wallet } from "thirdweb/wallets";
+
 export * from "./currency";
 
 export const siteURL = "https://basement.fun";
@@ -8,6 +10,12 @@ export const ecosystemWalletId = (process.env.NEXT_PUBLIC_THIRDWEB_ECOSYSTEM_ID
   process.env.EXPO_PUBLIC_THIRDWEB_ECOSYSTEM_ID ||
   "ecosystem.b3-open-gaming") as `ecosystem.${string}`; // Fallback to prod key lookup
 
+// Portable equivalent of thirdweb's `EcosystemWallet`, which thirdweb does not export
+// from any public entry point — declaration emit cannot name the internal type (TS2742).
+export type EcosystemWallet = Wallet<`ecosystem.${string}`> & {
+  getAuthToken: () => string | null;
+};
+
 export const tokenIcons = {
   ETH: "https://cdn.b3.fun/ethereum.svg",
   WETH: "https://cdn.b3.fun/wrapped-ethereum.svg",