@b3dotfun/sdk 0.1.70-alpha.18 → 0.1.70-alpha.19

package/src/anyspend/react/components/AnySpendStakeB3.tsx

@@ -8,7 +8,7 @@ import {
   toast,
   useHasMounted,
   useModalStore,
-  useSimBalance,
+  usePortfolioBalance,
   useUnifiedChainSwitchAndExecute,
 } from "@b3dotfun/sdk/global-account/react";
 import { PUBLIC_BASE_RPC_URL } from "@b3dotfun/sdk/shared/constants";
@@ -75,12 +75,32 @@ export function AnySpendStakeB3({
   const { address } = useAccount();
   const { switchChainAndExecute, isSwitchingOrExecuting } = useUnifiedChainSwitchAndExecute();
 
-  // Fetch B3 token balance
-  const { data: simBalance, isLoading: isBalanceLoading } = useSimBalance(address, [base.id]);
-  const b3RawBalanceStr = simBalance?.balances.find(b => eqci(b.address, B3_TOKEN.address))?.amount || "0";
+  // Fetch B3 token balance. `isBalanceUnknown` must gate every use of `b3RawBalance`: a failed read
+  // yields the same 0 as an empty wallet, and acting on it pushes a holder into the swap flow to
+  // buy a token they already have.
+  const {
+    data: balances,
+    isLoading: isBalanceLoading,
+    isError: isBalanceError,
+    refetch: refetchBalance,
+  } = usePortfolioBalance(address, [base.id]);
+  // Guarded on `address`: with no wallet connected the query never runs, and a query that was
+  // never asked is not a query that failed. Without this the screen tells a visitor their
+  // balance is unavailable and refuses to continue, when they simply have not connected yet.
+  const isBalanceUnknown = Boolean(address) && (isBalanceError || (!isBalanceLoading && balances === undefined));
+  const b3RawBalanceStr = balances?.find(b => eqci(b.address, B3_TOKEN.address))?.amount || "0";
   const b3RawBalance = BigInt(b3RawBalanceStr);
   const b3Balance = formatTokenAmount(b3RawBalance, B3_TOKEN.decimals);
 
+  /**
+   * Whether the wallet demonstrably holds enough B3 to stake `amountRaw` directly.
+   *
+   * False while the balance is unknown — but callers must not read that as a shortfall. An unknown
+   * balance is neither enough nor short, and the two need different UI: a shortfall offers the swap
+   * flow, an unknown offers a retry. Check `isBalanceUnknown` first.
+   */
+  const hasEnoughB3 = (amountRaw: string) => !isBalanceUnknown && BigInt(amountRaw || "0") <= b3RawBalance;
+
   // State for direct staking flow
   const [isStaking, setIsStaking] = useState(false);
   const [stakingTxHash, setStakingTxHash] = useState<string>("");
@@ -273,10 +293,12 @@ export function AnySpendStakeB3({
       return;
     }
 
-    // Check if user has sufficient B3 balance for direct staking
-    const hasEnoughBalance = b3RawBalance && BigInt(userStakeAmount) <= b3RawBalance;
+    if (isBalanceUnknown) {
+      toast.error("Can't read your B3 balance right now. Please try again.");
+      return;
+    }
 
-    if (hasEnoughBalance) {
+    if (hasEnoughB3(userStakeAmount)) {
       // User has enough B3, proceed with direct staking
       handleDirectStaking();
     } else {
@@ -334,10 +356,9 @@ export function AnySpendStakeB3({
               transition={{ duration: 0.3, delay: 0.1, ease: "easeInOut" }}
             >
               <h2 className="font-sf-rounded font-neue-montreal-medium mb-1 text-center text-2xl font-semibold">
-                {(() => {
-                  const hasEnoughBalance = b3RawBalance && BigInt(debouncedUserStakeAmount || "0") <= b3RawBalance;
-                  return hasEnoughBalance || !debouncedAmount ? "Stake B3" : "Swap & Stake B3";
-                })()}
+                {isBalanceUnknown || !debouncedAmount || hasEnoughB3(debouncedUserStakeAmount)
+                  ? "Stake B3"
+                  : "Swap & Stake B3"}
               </h2>
             </motion.div>
           </div>
@@ -356,7 +377,14 @@ export function AnySpendStakeB3({
               <div className="flex items-center justify-between">
                 <p className="text-as-primary/70 text-sm font-medium">I want to stake</p>
                 <span className="text-as-primary/50 flex items-center gap-1 text-sm">
-                  Available: {isBalanceLoading ? <Loader2 className="h-3 w-3 animate-spin" /> : `${b3Balance} B3`}
+                  Available:{" "}
+                  {isBalanceLoading ? (
+                    <Loader2 className="h-3 w-3 animate-spin" />
+                  ) : isBalanceUnknown ? (
+                    "unavailable"
+                  ) : (
+                    `${b3Balance} B3`
+                  )}
                 </span>
               </div>
             </div>
@@ -379,9 +407,22 @@ export function AnySpendStakeB3({
 
             <div className="mt-4">
               {(() => {
-                const hasEnoughBalance = b3RawBalance && BigInt(debouncedUserStakeAmount || "0") <= b3RawBalance;
+                // An unreadable balance is not a shortfall, so it must not open the swap upsell —
+                // that would sell a swap to someone who may already hold the tokens.
+                if (isBalanceUnknown) {
+                  return (
+                    <div className="bg-as-brand/10 flex flex-col items-center gap-2 rounded-lg p-4 pb-5">
+                      <p className="text-as-primary/70 text-sm font-medium">
+                        We couldn&apos;t read your B3 balance just now.
+                      </p>
+                      <Button variant="ghost" onClick={() => refetchBalance()} className="text-as-primary text-sm">
+                        Try again
+                      </Button>
+                    </div>
+                  );
+                }
 
-                if (!hasEnoughBalance || !debouncedAmount) {
+                if (!hasEnoughB3(debouncedUserStakeAmount) || !debouncedAmount) {
                   return (
                     <div className="bg-as-brand/10 flex flex-col items-center gap-2 rounded-lg p-4 pb-5">
                       <div className="flex items-center justify-center gap-2">

package/src/anyspend/react/components/AnySpendStakeB3ExactIn.tsx

@@ -9,7 +9,7 @@ import {
   toast,
   useHasMounted,
   useModalStore,
-  useSimBalance,
+  usePortfolioBalance,
   useUnifiedChainSwitchAndExecute,
 } from "@b3dotfun/sdk/global-account/react";
 import { PUBLIC_BASE_RPC_URL } from "@b3dotfun/sdk/shared/constants";
@@ -82,12 +82,32 @@ export function AnySpendStakeB3ExactIn({
   const { address } = useAccount();
   const { switchChainAndExecute, isSwitchingOrExecuting } = useUnifiedChainSwitchAndExecute();
 
-  // Fetch B3 token balance
-  const { data: simBalance, isLoading: isBalanceLoading } = useSimBalance(address, [base.id]);
-  const b3RawBalanceStr = simBalance?.balances.find(b => eqci(b.address, B3_TOKEN.address))?.amount || "0";
+  // Fetch B3 token balance. `isBalanceUnknown` must gate every use of `b3RawBalance`: a failed read
+  // yields the same 0 as an empty wallet, and acting on it pushes a holder into the swap flow to
+  // buy a token they already have.
+  const {
+    data: balances,
+    isLoading: isBalanceLoading,
+    isError: isBalanceError,
+    refetch: refetchBalance,
+  } = usePortfolioBalance(address, [base.id]);
+  // Guarded on `address`: with no wallet connected the query never runs, and a query that was
+  // never asked is not a query that failed. Without this the screen tells a visitor their
+  // balance is unavailable and refuses to continue, when they simply have not connected yet.
+  const isBalanceUnknown = Boolean(address) && (isBalanceError || (!isBalanceLoading && balances === undefined));
+  const b3RawBalanceStr = balances?.find(b => eqci(b.address, B3_TOKEN.address))?.amount || "0";
   const b3RawBalance = BigInt(b3RawBalanceStr);
   const b3Balance = formatTokenAmount(b3RawBalance, B3_TOKEN.decimals);
 
+  /**
+   * Whether the wallet demonstrably holds enough B3 to stake `amountRaw` directly.
+   *
+   * False while the balance is unknown — but callers must not read that as a shortfall. An unknown
+   * balance is neither enough nor short, and the two need different UI: a shortfall offers the swap
+   * flow, an unknown offers a retry. Check `isBalanceUnknown` first.
+   */
+  const hasEnoughB3 = (amountRaw: string) => !isBalanceUnknown && BigInt(amountRaw || "0") <= b3RawBalance;
+
   // State for direct staking flow
   const [isStaking, setIsStaking] = useState(false);
   const [stakingTxHash, setStakingTxHash] = useState<string>("");
@@ -283,9 +303,12 @@ export function AnySpendStakeB3ExactIn({
     }
 
     // Check if user has sufficient B3 balance for direct staking
-    const hasEnoughBalance = b3RawBalance && BigInt(userStakeAmount) <= b3RawBalance;
+    if (isBalanceUnknown) {
+      toast.error("Can't read your B3 balance right now. Please try again.");
+      return;
+    }
 
-    if (hasEnoughBalance) {
+    if (hasEnoughB3(userStakeAmount)) {
       // User has enough B3, proceed with direct staking
       handleDirectStaking();
     } else {
@@ -353,8 +376,9 @@ export function AnySpendStakeB3ExactIn({
             >
               <h2 className="font-sf-rounded font-neue-montreal-medium mb-1 text-center text-2xl font-semibold">
                 {(() => {
-                  const hasEnoughBalance = b3RawBalance && BigInt(debouncedUserStakeAmount || "0") <= b3RawBalance;
-                  return hasEnoughBalance || !debouncedAmount ? "Stake B3" : "Swap & Stake B3";
+                  return isBalanceUnknown || !debouncedAmount || hasEnoughB3(debouncedUserStakeAmount)
+                    ? "Stake B3"
+                    : "Swap & Stake B3";
                 })()}
               </h2>
             </motion.div>
@@ -374,7 +398,14 @@ export function AnySpendStakeB3ExactIn({
               <div className="flex items-center justify-between">
                 <p className="text-as-primary/70 text-sm font-medium">I want to stake</p>
                 <span className="text-as-primary/50 flex items-center gap-1 text-sm">
-                  Available: {isBalanceLoading ? <Loader2 className="h-3 w-3 animate-spin" /> : `${b3Balance} B3`}
+                  Available:{" "}
+                  {isBalanceLoading ? (
+                    <Loader2 className="h-3 w-3 animate-spin" />
+                  ) : isBalanceUnknown ? (
+                    "unavailable"
+                  ) : (
+                    `${b3Balance} B3`
+                  )}
                 </span>
               </div>
             </div>
@@ -397,9 +428,22 @@ export function AnySpendStakeB3ExactIn({
 
             <div className="mt-4">
               {(() => {
-                const hasEnoughBalance = b3RawBalance && BigInt(debouncedUserStakeAmount || "0") <= b3RawBalance;
+                // An unreadable balance is not a shortfall, so it must not open the swap upsell —
+                // that would sell a swap to someone who may already hold the tokens.
+                if (isBalanceUnknown) {
+                  return (
+                    <div className="bg-as-brand/10 flex flex-col items-center gap-2 rounded-lg p-4 pb-5">
+                      <p className="text-as-primary/70 text-sm font-medium">
+                        We couldn&apos;t read your B3 balance just now.
+                      </p>
+                      <Button variant="ghost" onClick={() => refetchBalance()} className="text-as-primary text-sm">
+                        Try again
+                      </Button>
+                    </div>
+                  );
+                }
 
-                if (!hasEnoughBalance || !debouncedAmount) {
+                if (!hasEnoughB3(debouncedUserStakeAmount) || !debouncedAmount) {
                   return (
                     <div className="bg-as-brand/10 flex flex-col items-center gap-2 rounded-lg p-4 pb-5">
                       <div className="flex items-center justify-center gap-2">

package/src/anyspend/react/components/__tests__/QRDeposit.test.tsx

@@ -89,10 +89,9 @@ vi.mock("@b3dotfun/sdk/global-account/react/hooks/useAccountWallet", () => ({
   useAccountWallet: () => ({ connectedEOAWallet: undefined }),
 }));
 
-vi.mock("@b3dotfun/sdk/global-account/react/hooks/useSimBalance", () => ({
-  useSimBalance: () => ({ data: undefined, isLoading: false }),
-  useSimSvmBalance: () => ({ data: undefined, isLoading: false }),
-  useSimTokenBalance: () => ({ data: undefined, isLoading: false }),
+vi.mock("@b3dotfun/sdk/global-account/react/hooks/usePortfolioBalance", () => ({
+  usePortfolioBalance: () => ({ data: undefined, isLoading: false, isError: false }),
+  usePortfolioTokenBalance: () => ({ data: undefined, isLoading: false, isError: false }),
 }));
 
 vi.mock("@b3dotfun/sdk/global-account/react/hooks/useTokenData", () => ({

package/src/anyspend/react/components/checkout/CryptoPayPanel.tsx

@@ -7,12 +7,12 @@ import { useAnyspendOrderAndTransactions } from "@b3dotfun/sdk/anyspend/react/ho
 import { useCreateDepositFirstOrder } from "@b3dotfun/sdk/anyspend/react/hooks/useCreateDepositFirstOrder";
 import { useOnOrderSuccess } from "@b3dotfun/sdk/anyspend/react/hooks/useOnOrderSuccess";
 import { ALL_CHAINS, RELAY_SOLANA_MAINNET_CHAIN_ID, getAvailableChainIds } from "@b3dotfun/sdk/anyspend";
-import { getPaymentUrl } from "@b3dotfun/sdk/anyspend/utils/chain";
+import { getPaymentUrl, toRegistryChainId } from "@b3dotfun/sdk/anyspend/utils/chain";
 import { isNativeToken } from "@b3dotfun/sdk/anyspend/utils/token";
 import {
   useAccountWallet,
   useIsMobile,
-  useSimTokenBalance,
+  usePortfolioTokenBalance,
   useTokenData,
   useUnifiedChainSwitchAndExecute,
 } from "@b3dotfun/sdk/global-account/react";
@@ -116,13 +116,21 @@ export function CryptoPayPanel({
       ? "native"
       : selectedSrcToken.address
     : undefined;
-  const { data: balanceData } = useSimTokenBalance(effectiveAddress, tokenAddress, selectedSrcChainId);
+  // `selectedSrcChainId` is Relay-numbered; balance rows are keyed by the chain registry's id.
+  const { data: balanceRow, isError: isBalanceError } = usePortfolioTokenBalance(
+    effectiveAddress,
+    tokenAddress,
+    toRegistryChainId(selectedSrcChainId),
+  );
 
   const balance = useMemo(() => {
-    const b = balanceData?.balances?.[0];
-    if (!b?.amount) return { raw: BigInt(0), formatted: "0", decimals: 18 };
-    return { raw: BigInt(b.amount), formatted: formatTokenAmount(BigInt(b.amount), b.decimals), decimals: b.decimals };
-  }, [balanceData]);
+    if (!balanceRow?.amount) return { raw: BigInt(0), formatted: "0", decimals: 18 };
+    return {
+      raw: BigInt(balanceRow.amount),
+      formatted: formatTokenAmount(BigInt(balanceRow.amount), balanceRow.decimals),
+      decimals: balanceRow.decimals,
+    };
+  }, [balanceRow]);
 
   const srcAmount = useMemo(() => {
     if (isSameToken) return totalAmount;
@@ -134,7 +142,9 @@ export function CryptoPayPanel({
     return formatTokenAmount(BigInt(srcAmount || "0"), selectedSrcToken.decimals || 18);
   }, [srcAmount, selectedSrcToken]);
 
-  const hasEnoughBalance = balance.raw >= BigInt(srcAmount || "0");
+  // A failed balance read must not masquerade as a shortfall: it would disable Pay and tell a
+  // funded user they are short. Unknown blocks auto-pay but leaves the manual path open.
+  const hasEnoughBalance = !isBalanceError && balance.raw >= BigInt(srcAmount || "0");
 
   /* ------------------------------------------------------------------ */
   /* Destination token object (shared by both flows)                    */
@@ -385,7 +395,8 @@ export function CryptoPayPanel({
 
   const isLoading = isLoadingAnyspendQuote;
   const isPending = isCreatingSwapOrder || isSendingDeposit || isWaitingForExecution;
-  const canPay = connectedAddress && selectedSrcToken && hasEnoughBalance && !isLoading && !isPending;
+  const canPay =
+    connectedAddress && selectedSrcToken && (hasEnoughBalance || isBalanceError) && !isLoading && !isPending;
 
   const chainName = ALL_CHAINS[selectedSrcChainId]?.name || "the specified chain";
   const chainLogoUrl = ALL_CHAINS[selectedSrcChainId]?.logoUrl;
@@ -494,7 +505,7 @@ export function CryptoPayPanel({
         </div>
       </motion.div>
 
-      {/* ---- Insufficient balance warning ---- */}
+      {/* ---- Balance warning ---- */}
       <AnimatePresence>
         {connectedAddress && selectedSrcToken && !hasEnoughBalance && !isLoading && (
           <motion.p
@@ -503,9 +514,11 @@ export function CryptoPayPanel({
             animate={{ opacity: 1, height: "auto" }}
             exit={{ opacity: 0, height: 0 }}
             transition={{ duration: 0.2, ease: "easeOut" }}
-            className="text-center text-sm text-red-500"
+            className={`text-center text-sm ${isBalanceError ? "text-as-primary/50" : "text-red-500"}`}
           >
-            Insufficient {selectedSrcToken.symbol} balance
+            {isBalanceError
+              ? `Couldn't check your ${selectedSrcToken.symbol} balance`
+              : `Insufficient ${selectedSrcToken.symbol} balance`}
           </motion.p>
         )}
       </AnimatePresence>

package/src/anyspend/react/components/common/TokenBalance.tsx

@@ -1,7 +1,7 @@
 import { components } from "@b3dotfun/sdk/anyspend/types/api";
-import { getNativeRequired } from "@b3dotfun/sdk/anyspend/utils/chain";
+import { getNativeRequired, toRegistryChainId } from "@b3dotfun/sdk/anyspend/utils/chain";
 import { isNativeToken } from "@b3dotfun/sdk/anyspend/utils/token";
-import { useSimTokenBalance } from "@b3dotfun/sdk/global-account/react";
+import { usePortfolioTokenBalance } from "@b3dotfun/sdk/global-account/react";
 import { formatTokenAmount } from "@b3dotfun/sdk/shared/utils/number";
 import { useMemo } from "react";
 import { formatUnits } from "viem";
@@ -15,11 +15,14 @@ export function TokenBalance({
   walletAddress: string | undefined;
   onChangeInput: (value: string) => void;
 }) {
-  const tokenAddress = isNativeToken(token.address) ? "native" : token.address;
-  const { data, isLoading } = useSimTokenBalance(walletAddress, tokenAddress, token.chainId);
+  // `token.chainId` is Relay-numbered; balance rows are keyed by the chain registry's id.
+  const {
+    data: balance,
+    isLoading,
+    isError,
+  } = usePortfolioTokenBalance(walletAddress, token.address, toRegistryChainId(token.chainId));
 
   const { rawBalance, formattedBalance } = useMemo(() => {
-    const balance = data?.balances?.[0];
     if (!balance?.amount) {
       return { rawBalance: null, formattedBalance: "0" };
     }
@@ -28,7 +31,7 @@ export function TokenBalance({
       rawBalance: raw,
       formattedBalance: formatTokenAmount(raw, balance.decimals),
     };
-  }, [data]);
+  }, [balance]);
 
   const handlePercentageClick = (percentage: number) => {
     if (!rawBalance) return;
@@ -59,7 +62,7 @@ export function TokenBalance({
       {!isLoading && (
         <>
           <div className="text-as-primary/50 inline-flex rounded-lg text-sm">
-            {rawBalance ? `Balance: ${formattedBalance}` : `Balance: 0`}
+            {isError ? "Balance: —" : rawBalance ? `Balance: ${formattedBalance}` : `Balance: 0`}
           </div>
 
           {!!rawBalance && (

package/src/anyspend/utils/__tests__/deprecatedChains.test.ts

@@ -0,0 +1,44 @@
+/**
+ * Deprecated chains must disappear from the chain picker but stay in ALL_CHAINS.
+ *
+ * Those are two different questions. ALL_CHAINS answers "what is this chain" and is needed to
+ * render every order that ever existed — anyspend has ~1,400 historical orders on B3 and Plume, and
+ * getChainName throws on an unknown id. getAvailableChainIds answers "can a new order use this",
+ * which is what the deprecation actually changes.
+ */
+import { describe, expect, it } from "vitest";
+
+import { ALL_CHAINS, DEPRECATED_CHAIN_IDS, getAvailableChainIds, isDeprecatedChain } from "../chain";
+
+describe("deprecated chains", () => {
+  it("covers B3 and Plume", () => {
+    expect(DEPRECATED_CHAIN_IDS).toContain(8333);
+    expect(DEPRECATED_CHAIN_IDS).toContain(98866);
+    expect(isDeprecatedChain(8333)).toBe(true);
+    expect(isDeprecatedChain(98866)).toBe(true);
+    expect(isDeprecatedChain(8453)).toBe(false);
+    expect(isDeprecatedChain(undefined)).toBe(false);
+  });
+
+  // Offering a chain the API rejects lets a user pick something that then fails at order creation.
+  it("are absent from the picker in both directions", () => {
+    for (const context of ["from", "to"] as const) {
+      const available = getAvailableChainIds(context);
+      for (const chainId of DEPRECATED_CHAIN_IDS) {
+        expect(available).not.toContain(chainId);
+      }
+    }
+  });
+
+  it("still leaves the picker with the chains that do work", () => {
+    expect(getAvailableChainIds("to")).toContain(8453);
+    expect(getAvailableChainIds("from")).toContain(1);
+  });
+
+  // Removing the entry would make getChainName and friends throw while rendering old orders.
+  it("remain in ALL_CHAINS so historical orders still render", () => {
+    for (const chainId of DEPRECATED_CHAIN_IDS) {
+      expect(ALL_CHAINS[chainId]).toBeDefined();
+    }
+  });
+});

package/src/anyspend/utils/__tests__/toRegistryChainId.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { RELAY_SOLANA_MAINNET_CHAIN_ID } from "@b3dotfun/sdk/anyspend/constants";
+import { toRegistryChainId } from "../chain";
+import { SOLANA_CHAIN_ID } from "@b3dotfun/sdk/shared/utils/zerionPositions";
+
+describe("toRegistryChainId", () => {
+  it("translates Relay's Solana id to the registry's", () => {
+    expect(RELAY_SOLANA_MAINNET_CHAIN_ID).not.toBe(SOLANA_CHAIN_ID);
+    expect(toRegistryChainId(RELAY_SOLANA_MAINNET_CHAIN_ID)).toBe(SOLANA_CHAIN_ID);
+  });
+
+  it("leaves EVM chain ids alone — those are universal", () => {
+    for (const chainId of [1, 8453, 42161, 137, 999]) {
+      expect(toRegistryChainId(chainId)).toBe(chainId);
+    }
+  });
+});

package/src/anyspend/utils/chain.ts

@@ -1,4 +1,5 @@
 import { RELAY_SOLANA_MAINNET_CHAIN_ID } from "@b3dotfun/sdk/anyspend/constants";
+import { SOLANA_CHAIN_ID } from "@b3dotfun/sdk/shared/utils/zerionPositions";
 import {
   ABSTRACT_PUBLIC_RPC,
   ARBITRUM_PUBLIC_RPC,
@@ -10,6 +11,7 @@ import {
   OPTIMISM_PUBLIC_RPC,
   PLUME_PUBLIC_RPC,
   POLYGON_PUBLIC_RPC,
+  ROBINHOOD_PUBLIC_RPC,
 } from "@b3dotfun/sdk/anyspend/constants/rpc";
 import { components } from "@b3dotfun/sdk/anyspend/types/api";
 import { b3Viem } from "@b3dotfun/sdk/shared/constants/chains/b3Viem";
@@ -26,7 +28,7 @@ import {
   Transport,
   WalletClient,
 } from "viem";
-import { abstract, arbitrum, avalanche, base, bsc, mainnet, optimism, polygon } from "viem/chains";
+import { abstract, arbitrum, avalanche, base, bsc, mainnet, optimism, polygon, robinhood } from "viem/chains";
 import { ChainType, IBaseChain, IEVMChain, IHyperliquidChain, ISolanaChain } from "../types/chain";
 import {
   getAvaxToken,
@@ -272,6 +274,20 @@ export const EVM_MAINNET: Record<number, IEVMChain> = {
     coingeckoName: "plume-network",
     wethAddress: "0xea237441c92cae6fc17caaf9a7acb3f953be4bd1", // WPLUME (wrapped native)
   },
+  [robinhood.id]: {
+    id: robinhood.id,
+    name: robinhood.name,
+    logoUrl: "https://assets.relay.link/icons/square/4663/light.png",
+    type: ChainType.EVM,
+    nativeRequired: parseEther("0.0001"),
+    canDepositNative: true,
+    defaultToken: getEthToken(robinhood.id),
+    nativeToken: getEthToken(robinhood.id),
+    viem: getCustomEvmChain(robinhood, ROBINHOOD_PUBLIC_RPC),
+    pollingInterval: 1000, // 1 second for Robinhood Chain (Arbitrum Orbit fast blocks)
+    coingeckoName: "robinhood",
+    wethAddress: "0x0bd7d308f8e1639fab988df18a8011f41eacad73", // wrapped native ETH (registry wrappedNative)
+  },
 };
 
 export const EVM_TESTNET: Record<number, IEVMChain> = {
@@ -356,6 +372,17 @@ export const EVM_CHAINS: Record<number, IEVMChain> = { ...EVM_MAINNET, ...EVM_TE
 
 export const SOLANA_CHAINS: Record<number, ISolanaChain> = { [RELAY_SOLANA_MAINNET_CHAIN_ID]: SOLANA_MAINNET };
 
+/**
+ * Translate a Relay-numbered chain id into the id the chain registry uses.
+ *
+ * Relay numbers Solana 792703809; every other chain shares the universal EVM id. Balance rows are
+ * keyed by the registry's id, so handing Relay's number to a balance lookup matches nothing at all
+ * — and a funded Solana wallet then reads as empty rather than as unreadable.
+ */
+export function toRegistryChainId(chainId: number): number {
+  return chainId === RELAY_SOLANA_MAINNET_CHAIN_ID ? SOLANA_CHAIN_ID : chainId;
+}
+
 export const HYPERLIQUID_CHAINS: Record<number, IHyperliquidChain> = {
   [HYPERLIQUID_CHAIN_ID]: HYPERLIQUID_MAINNET,
 };
@@ -680,6 +707,26 @@ export function getHyperliquidChain(chainId: number): IHyperliquidChain {
   return HYPERLIQUID_CHAINS[chainId];
 }
 
+/**
+ * Chains AnySpend no longer accepts orders on, as either source or destination.
+ *
+ * They stay in ALL_CHAINS on purpose. That map answers "what is this chain" — name, logo, token,
+ * decimals — which every order that ever existed still needs in order to render; removing an entry
+ * would make getChainName and friends throw on historical rows. Whether new orders are accepted is
+ * this separate question.
+ *
+ * anyspend-service imports this list rather than keeping its own, so the API and the chain picker
+ * can never disagree about what is on offer.
+ */
+export const DEPRECATED_CHAIN_IDS: readonly number[] = [
+  8333, // B3
+  98866, // Plume
+];
+
+export function isDeprecatedChain(chainId?: number): boolean {
+  return chainId !== undefined && DEPRECATED_CHAIN_IDS.includes(chainId);
+}
+
 /**
  * Get available chain IDs for AnySpend based on context (source or destination).
  * Filters out chains that shouldn't be available for the given context.
@@ -695,7 +742,11 @@ export function getHyperliquidChain(chainId: number): IHyperliquidChain {
  * const destChains = getAvailableChainIds("to") // [1, 8453, 137, ..., 1337]
  */
 export function getAvailableChainIds(context: "from" | "to"): number[] {
-  const allChainIds = Object.values(ALL_CHAINS).map(chain => chain.id);
+  // Deprecated chains are excluded from both directions: the API rejects them, so offering them in
+  // a picker would let a user select something that then fails at order creation.
+  const allChainIds = Object.values(ALL_CHAINS)
+    .map(chain => chain.id)
+    .filter(chainId => !isDeprecatedChain(chainId));
 
   if (context === "from") {
     // Hyperliquid is only supported as destination chain, not source chain

package/src/global-account/react/components/B3Provider/B3Provider.tsx

@@ -37,7 +37,6 @@ export function B3Provider({
   environment,
   automaticallySetFirstEoa,
   defaultEoaProvider,
-  simDuneApiKey,
   // deprecated since v0.0.87
   toaster: _toaster,
   clientType = "rest",
@@ -63,7 +62,6 @@ export function B3Provider({
   automaticallySetFirstEoa?: boolean;
   /** EIP-1193 provider to auto-connect as the default EOA wallet (e.g., Farcaster frame wallet) */
   defaultEoaProvider?: EIP1193.EIP1193Provider;
-  simDuneApiKey?: string;
   toaster?: {
     position?: "top-center" | "top-right" | "bottom-center" | "bottom-right";
     style?: React.CSSProperties;
@@ -150,7 +148,7 @@ export function B3Provider({
               authStrategy={authStrategy}
             >
               <ToastContextConnector />
-              <RelayKitProviderWrapper simDuneApiKey={simDuneApiKey}>
+              <RelayKitProviderWrapper>
                 {children}
                 {/* For the modal https://github.com/b3-fun/b3/blob/main/packages/sdk/src/global-account/react/components/ui/dialog.tsx#L46 */}
                 <StyleRoot id="b3-root" />

package/src/global-account/react/components/B3Provider/RelayKitProviderWrapper.tsx

@@ -2,13 +2,7 @@ import { RelayKitProvider } from "@relayprotocol/relay-kit-ui";
 import { fetchChainConfigs, MAINNET_RELAY_API, RelayChain } from "@relayprotocol/relay-sdk";
 import { useEffect, useState } from "react";
 
-export function RelayKitProviderWrapper({
-  children,
-  simDuneApiKey,
-}: {
-  children: React.ReactNode;
-  simDuneApiKey?: string;
-}) {
+export function RelayKitProviderWrapper({ children }: { children: React.ReactNode }) {
   const [relayChains, setRelayChains] = useState<RelayChain[]>([]);
 
   useEffect(() => {
@@ -19,15 +13,14 @@ export function RelayKitProviderWrapper({
     fetchChains();
   }, []);
 
+  // No balance provider is configured for Relay's own token selector. Relay reads balances through
+  // its Dune integration, which we no longer hold a key for, and it accepts no substitute — so the
+  // selector lists tokens without balances rather than showing figures nothing can refresh.
   return (
     <RelayKitProvider
       options={{
         baseApiUrl: MAINNET_RELAY_API,
         source: "anyspend",
-        duneConfig: {
-          apiKey: simDuneApiKey,
-          apiBaseUrl: "https://api.sim.dune.com",
-        },
         chains: relayChains,
         privateChainIds: undefined,
         appName: "AnySpend",