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

package/src/shared/react/hooks/__tests__/useCurrencyConversion.test.ts

@@ -1,25 +1,27 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
 import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { useCurrencyConversion } from "../useCurrencyConversion";
 
 // Mock the external dependencies
 // Store mock rates for different quote currencies
 const mockRates: Record<string, number | undefined> = {};
 
-// Mock store state
 const mockStoreState: any = {
   selectedCurrency: "B3",
   baseCurrency: "B3",
+  customCurrencies: {},
+  getExchangeRate: vi.fn(() => undefined),
   setSelectedCurrency: vi.fn(),
   setBaseCurrency: vi.fn(),
 };
 
-vi.mock("@b3dotfun/sdk/global-account/react", () => ({
-  useExchangeRate: vi.fn((params: any) => {
-    const rate = mockRates[params?.quoteCurrency];
-    return { rate };
-  }),
-}));
+vi.mock("@tanstack/react-query", async importOriginal => {
+  const actual = await importOriginal<typeof import("@tanstack/react-query")>();
+  return {
+    ...actual,
+    useQuery: vi.fn(() => ({ data: mockRates })),
+  };
+});
 
 vi.mock("@b3dotfun/sdk/shared/utils/number", () => ({
   formatDisplayNumber: vi.fn((value: any) => {
@@ -29,14 +31,8 @@ vi.mock("@b3dotfun/sdk/shared/utils/number", () => ({
   }),
 }));
 
-vi.mock("../../stores/currencyStore", () => ({
-  useCurrencyStore: vi.fn((selector: any) => {
-    if (selector) {
-      return selector(mockStoreState);
-    }
-    return mockStoreState;
-  }),
-  CURRENCY_SYMBOLS: {
+vi.mock("../../stores/currencyStore", () => {
+  const symbols: Record<string, string> = {
     B3: "B3",
     USD: "$",
     EUR: "€",
@@ -47,8 +43,23 @@ vi.mock("../../stores/currencyStore", () => ({
     ETH: "ETH",
     SOL: "SOL",
     KRW: "₩",
-  },
-}));
+  };
+
+  return {
+    useCurrencyStore: vi.fn((selector: any) => {
+      if (selector) {
+        return selector(mockStoreState);
+      }
+      return mockStoreState;
+    }),
+    getCurrencySymbol: vi.fn((currency: string) => symbols[currency] ?? currency),
+    getCurrencyMetadata: vi.fn(() => undefined),
+  };
+});
+
+function renderCurrencyConversion() {
+  return renderHook(() => useCurrencyConversion());
+}
 
 describe("useCurrencyConversion", () => {
   beforeEach(() => {
@@ -66,7 +77,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "B3";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toContain("B3");
@@ -78,7 +89,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toContain("B3");
@@ -90,7 +101,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toMatch(/^\$/);
@@ -103,7 +114,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "EUR";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toMatch(/^€/);
@@ -115,7 +126,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "JPY";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toContain("¥");
@@ -128,7 +139,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "KRW";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toContain("₩");
@@ -141,7 +152,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "ETH";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toContain("ETH");
@@ -154,7 +165,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "SOL";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(100, "B3");
 
       expect(formatted).toContain("SOL");
@@ -166,7 +177,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const formatted = result.current.formatCurrencyValue(10, "B3");
 
       // 10 * 1.5 = 15
@@ -180,7 +191,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const inputValue = 100;
       const formatted = result.current.formatCurrencyValue(inputValue, "B3");
 
@@ -193,7 +204,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
 
       expect(result.current.selectedCurrency).toBe("USD");
     });
@@ -202,7 +213,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
 
       expect(result.current.baseCurrency).toBe("B3");
     });
@@ -213,7 +224,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
 
       expect(result.current.exchangeRate).toBe(testRate);
     });
@@ -222,7 +233,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "EUR";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
 
       expect(result.current.selectedCurrencySymbol).toBe("€");
       expect(result.current.baseCurrencySymbol).toBe("B3");
@@ -235,24 +246,24 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "B3";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const tooltip = result.current.formatTooltipValue(100, "B3");
 
       expect(tooltip).toContain("USD");
       expect(tooltip).toContain("150");
     });
 
-    it("should show base currency when displaying other currency", () => {
+    it("shows the USD equivalent regardless of selected display currency", () => {
       mockRates.EUR = 0.9;
       mockRates.USD = 1.2;
       mockStoreState.selectedCurrency = "EUR";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const tooltip = result.current.formatTooltipValue(100, "B3");
 
-      expect(tooltip).toContain("B3");
-      expect(tooltip).toContain("100");
+      expect(tooltip).toContain("USD");
+      expect(tooltip).toContain("120");
     });
 
     it("should handle custom currency for base currency", () => {
@@ -261,7 +272,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "EUR";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const tooltip = result.current.formatTooltipValue(100, "B3");
 
       expect(tooltip).toContain("USD");
@@ -273,7 +284,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "USD";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const tooltip = result.current.formatTooltipValue(50, "ETH");
 
       expect(tooltip).toContain("ETH");
@@ -285,7 +296,7 @@ describe("useCurrencyConversion", () => {
       mockStoreState.selectedCurrency = "B3";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const tooltip = result.current.formatTooltipValue(-100, "B3");
 
       expect(tooltip).toContain("USD");
@@ -293,15 +304,15 @@ describe("useCurrencyConversion", () => {
       expect(tooltip).not.toContain("-");
     });
 
-    it("should handle exchange rate unavailable", () => {
+    it("falls back to the source currency when its USD rate is unavailable", () => {
       mockRates.USD = undefined;
       mockStoreState.selectedCurrency = "B3";
       mockStoreState.baseCurrency = "B3";
 
-      const { result } = renderHook(() => useCurrencyConversion());
+      const { result } = renderCurrencyConversion();
       const tooltip = result.current.formatTooltipValue(100, "B3");
 
-      expect(tooltip).toContain("USD");
+      expect(tooltip).toContain("B3");
       expect(tooltip).toContain("100");
     });
   });

package/src/shared/utils/__tests__/zerionPositions.test.ts

@@ -0,0 +1,248 @@
+import { isSolanaAddress as registryIsSolanaAddress, SOLANA_NATIVE_ASSET } from "@b3/chain-registry/runtime";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import { isSolanaAddress as sdkIsSolanaAddress } from "../../../anyspend/utils/address";
+import {
+  adaptZerionPositions,
+  chainIdToZerionSlug,
+  EVM_NATIVE_TOKEN_ADDRESS,
+  SOLANA_CHAIN_ID,
+  SOLANA_NATIVE_TOKEN_ADDRESS,
+  SOLANA_ZERION_SLUG,
+  zerionSlugToChainId,
+  type ZerionPositionLike,
+} from "../zerionPositions";
+
+// Slugs and ids below are shaped after live Zerion responses.
+const SLUG_TO_CHAIN_ID: Record<string, number> = {
+  ethereum: 1,
+  base: 8453,
+  polygon: 137,
+  celo: 42220,
+  hyperevm: 999,
+};
+const slugToChainId = (slug: string) => SLUG_TO_CHAIN_ID[slug];
+
+function position(overrides: {
+  id: string;
+  slug: string;
+  symbol: string;
+  implAddress?: string | null;
+  implDecimals?: number;
+  quantityDecimals?: number;
+  int?: string;
+}): ZerionPositionLike {
+  const { id, slug, symbol, implAddress = null, implDecimals = 18, quantityDecimals = 18, int = "1000" } = overrides;
+  return {
+    id,
+    attributes: {
+      quantity: { int, decimals: quantityDecimals },
+      fungible_info: {
+        symbol,
+        implementations: [{ chain_id: slug, address: implAddress, decimals: implDecimals }],
+      },
+    },
+    relationships: { chain: { data: { id: slug } } },
+  };
+}
+
+describe("adaptZerionPositions native detection", () => {
+  it("treats a null implementation address as the chain's native coin", () => {
+    const [row] = adaptZerionPositions(
+      [position({ id: "base-base-asset-asset", slug: "base", symbol: "ETH" })],
+      slugToChainId,
+    );
+
+    expect(row.is_native).toBe(true);
+    expect(row.address).toBe(EVM_NATIVE_TOKEN_ADDRESS);
+  });
+
+  it("treats Polygon's native coin as native despite its system-contract address", () => {
+    const [row] = adaptZerionPositions(
+      [
+        position({
+          id: "base-polygon-asset-asset",
+          slug: "polygon",
+          symbol: "POL",
+          implAddress: "0x0000000000000000000000000000000000001010",
+        }),
+      ],
+      slugToChainId,
+    );
+
+    expect(row.is_native).toBe(true);
+    expect(row.address).toBe(EVM_NATIVE_TOKEN_ADDRESS);
+  });
+
+  it("treats Celo's native coin as native despite its ERC-20 address", () => {
+    const [row] = adaptZerionPositions(
+      [
+        position({
+          id: "base-celo-asset-asset",
+          slug: "celo",
+          symbol: "celo",
+          implAddress: "0x471ece3750da237f93b8e339c536989b8978a438",
+        }),
+      ],
+      slugToChainId,
+    );
+
+    expect(row.is_native).toBe(true);
+  });
+
+  it("keeps a same-symbol non-native fungible distinct from the native coin", () => {
+    const rows = adaptZerionPositions(
+      [
+        position({
+          id: "base-polygon-asset-asset",
+          slug: "polygon",
+          symbol: "POL",
+          implAddress: "0x0000000000000000000000000000000000001010",
+        }),
+        position({
+          id: "0x89299a4c719ebe9fe6018aed81eb1d48b4f78d56-polygon-asset-asset",
+          slug: "polygon",
+          symbol: "POL",
+          implAddress: "0x89299a4c719ebe9fe6018aed81eb1d48b4f78d56",
+        }),
+      ],
+      slugToChainId,
+    );
+
+    expect(rows.map(r => r.is_native)).toEqual([true, false]);
+    expect(rows[1].address).toBe("0x89299a4c719ebe9fe6018aed81eb1d48b4f78d56");
+  });
+});
+
+describe("adaptZerionPositions row filtering", () => {
+  it("drops a row whose chain is unmapped", () => {
+    const rows = adaptZerionPositions(
+      [position({ id: "base-unknownchain-asset-asset", slug: "unknownchain", symbol: "???" })],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops a row whose fungible has no implementation on its chain, rather than calling it native", () => {
+    const rows = adaptZerionPositions(
+      [
+        {
+          id: "0xabc-ethereum-asset-asset",
+          attributes: {
+            quantity: { int: "1000", decimals: 18 },
+            fungible_info: {
+              symbol: "ORPHAN",
+              // implementations exist, but none for the position's own chain
+              implementations: [{ chain_id: "polygon", address: "0xabc", decimals: 18 }],
+            },
+          },
+          relationships: { chain: { data: { id: "ethereum" } } },
+        },
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops a row that carries no quantity rather than reporting a zero balance", () => {
+    const rows = adaptZerionPositions(
+      [
+        {
+          id: "base-base-asset-asset",
+          attributes: {
+            quantity: { decimals: 18 },
+            fungible_info: { symbol: "ETH", implementations: [{ chain_id: "base", address: null, decimals: 18 }] },
+          },
+          relationships: { chain: { data: { id: "base" } } },
+        },
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops a row that carries no decimals rather than guessing a scale", () => {
+    const rows = adaptZerionPositions(
+      [
+        {
+          id: "0xabc-ethereum-asset-asset",
+          attributes: {
+            quantity: { int: "1000" },
+            fungible_info: { symbol: "MYSTERY", implementations: [{ chain_id: "ethereum", address: "0xabc" }] },
+          },
+          relationships: { chain: { data: { id: "ethereum" } } },
+        },
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops trash and non-displayable rows", () => {
+    const base = position({ id: "0xspam-ethereum-asset-asset", slug: "ethereum", symbol: "SPAM" });
+    const spam: ZerionPositionLike = { ...base, attributes: { ...base.attributes, flags: { is_trash: true } } };
+    const hidden: ZerionPositionLike = {
+      ...base,
+      attributes: { ...base.attributes, flags: { displayable: false } },
+    };
+
+    expect(adaptZerionPositions([spam, hidden], slugToChainId)).toEqual([]);
+  });
+
+  it("drops any quantity that is not a base-10 integer, since all of them format to NaN", () => {
+    const rows = adaptZerionPositions(
+      [
+        position({ id: "0xa-ethereum-asset-asset", slug: "ethereum", symbol: "A", int: "" }),
+        position({ id: "0xb-ethereum-asset-asset", slug: "ethereum", symbol: "B", int: null as unknown as string }),
+        position({ id: "0xc-ethereum-asset-asset", slug: "ethereum", symbol: "C", int: "not-a-number" }),
+        position({ id: "0xd-ethereum-asset-asset", slug: "ethereum", symbol: "D", int: "0x1f" }),
+        position({ id: "0xe-ethereum-asset-asset", slug: "ethereum", symbol: "E", int: "1.5" }),
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("keeps a genuine zero balance", () => {
+    const [row] = adaptZerionPositions(
+      [position({ id: "base-ethereum-asset-asset", slug: "ethereum", symbol: "ETH", int: "0" })],
+      slugToChainId,
+    );
+
+    expect(row.amount).toBe("0");
+  });
+});
+
+describe("zerionSlugToChainId", () => {
+  it("reports an inherited object key as an unknown chain", () => {
+    // Slugs come off the wire; an object lookup would answer `constructor` with a function.
+    expect(zerionSlugToChainId("constructor")).toBeUndefined();
+    expect(zerionSlugToChainId("toString")).toBeUndefined();
+  });
+
+  it("still resolves a real slug", () => {
+    expect(zerionSlugToChainId("ethereum")).toBe(1);
+    expect(chainIdToZerionSlug(8453)).toBe("base");
+  });
+});
+
+describe("canonical Solana registry compatibility", () => {
+  it("preserves published SDK values and literal types", () => {
+    expect(SOLANA_NATIVE_TOKEN_ADDRESS).toBe(SOLANA_NATIVE_ASSET.wrapped.address);
+    expect(SOLANA_ZERION_SLUG).toBe(SOLANA_NATIVE_ASSET.chain);
+    expect(SOLANA_CHAIN_ID).toBe(SOLANA_NATIVE_ASSET.chainId);
+    expectTypeOf(SOLANA_NATIVE_TOKEN_ADDRESS).toEqualTypeOf<"So11111111111111111111111111111111111111112">();
+    expectTypeOf(SOLANA_ZERION_SLUG).toEqualTypeOf<"solana">();
+    expectTypeOf(SOLANA_CHAIN_ID).toEqualTypeOf<7565164>();
+  });
+
+  it("re-exports the registry Solana address guard unchanged", () => {
+    expect(sdkIsSolanaAddress).toBe(registryIsSolanaAddress);
+    expect(sdkIsSolanaAddress(SOLANA_NATIVE_TOKEN_ADDRESS)).toBe(true);
+    expect(sdkIsSolanaAddress("So1111111111111111111111111111111111111111O")).toBe(false);
+  });
+});

package/src/shared/utils/chain-transformers.ts

@@ -1,51 +1,53 @@
-import type { ChainNetworks } from "@b3dotfun/sdk/global-account/types/chain-networks";
+import type { ChainDefinition } from "@b3/chain-registry";
 import type { Chain as ThirdwebChain } from "thirdweb";
 import { defineChain as defineThirdwebChain } from "thirdweb";
-import { Chain } from "viem";
+import type { Chain } from "viem";
 
-export function toViemChain(network: ChainNetworks): Chain {
+// fallbackRpc is validated non-null at chain-registry module init for every
+// anyspend EVM chain (see ANYSPEND_EVM_CHAINS in @b3/chain-registry). Callers
+// outside the anyspend EVM set must ensure their own data shape.
+
+// Derive icon format from URL extension. Thirdweb chain config carries an
+// explicit `format` field; the old chain-networks.json had per-chain values
+// (svg/png/etc.) but @b3/chain-registry only stores `logoUrl`. URL extension
+// is reliable across our current chain set — 9/11 anyspend chains use .png
+// (trustwallet/relay/coinmarketcap), 2 use .svg (Base, Plume from cdn.b3.fun).
+function inferIconFormat(url: string): string {
+  const match = url.toLowerCase().match(/\.([a-z0-9]+)(?:\?|#|$)/);
+  const ext = match?.[1];
+  if (ext === "png" || ext === "jpg" || ext === "jpeg" || ext === "gif" || ext === "webp") return ext;
+  return "svg";
+}
+
+export function toViemChain(chain: ChainDefinition): Chain {
+  if (!chain.fallbackRpc) {
+    throw new Error(`toViemChain: chain ${chain.chainId} (${chain.key}) has no fallbackRpc`);
+  }
   return {
-    id: network.id,
-    name: network.name,
-    nativeCurrency: network.nativeCurrency,
-    rpcUrls: {
-      default: {
-        http: [network.rpcUrls.default.http],
-        webSocket: network.rpcUrls.default.ws ? [network.rpcUrls.default.ws] : undefined,
-      },
-    },
+    id: chain.chainId,
+    name: chain.name,
+    nativeCurrency: chain.nativeCurrency,
+    rpcUrls: { default: { http: [chain.fallbackRpc] } },
     blockExplorers: {
-      default: {
-        name: network.blockExplorers.explorerTitle,
-        url: network.blockExplorers.default,
-      },
+      default: { name: `${chain.name} Explorer`, url: chain.explorer },
     },
-    contracts: network.contracts,
-    testnet: network.testnet,
-    sourceId: network.sourceId,
-    formatters: network.formatters,
-    fees: network.fees,
+    testnet: chain.isTestnet,
   };
 }
 
-export function toThirdwebChain(network: ChainNetworks): ThirdwebChain {
+export function toThirdwebChain(chain: ChainDefinition): ThirdwebChain {
+  if (!chain.fallbackRpc) {
+    throw new Error(`toThirdwebChain: chain ${chain.chainId} (${chain.key}) has no fallbackRpc`);
+  }
   return defineThirdwebChain({
-    id: network.id,
-    name: network.name,
-    nativeCurrency: network.nativeCurrency,
-    rpc: network.rpcUrls.default.http,
-    icon: {
-      url: network.icon.url,
-      width: network.icon.width,
-      height: network.icon.height,
-      format: network.icon.format,
-    },
-    blockExplorers: [
-      {
-        name: network.blockExplorers.explorerTitle,
-        url: network.blockExplorers.default,
-      },
-    ],
-    testnet: network.testnet ? true : undefined,
+    id: chain.chainId,
+    name: chain.name,
+    nativeCurrency: chain.nativeCurrency,
+    rpc: chain.fallbackRpc,
+    icon: chain.logoUrl
+      ? { url: chain.logoUrl, width: 32, height: 32, format: inferIconFormat(chain.logoUrl) }
+      : undefined,
+    blockExplorers: [{ name: `${chain.name} Explorer`, url: chain.explorer }],
+    testnet: chain.isTestnet ? true : undefined,
   });
 }

package/src/shared/utils/thirdweb-insights.ts

@@ -291,7 +291,7 @@ export async function getNativeTokenBalance(address: string, chainId: number): P
 
   try {
     // Find chain info from supported chains
-    const chainInfo = supportedChainNetworks.find(chain => chain.id === chainId);
+    const chainInfo = supportedChainNetworks.find(chain => chain.chainId === chainId);
 
     // Create a chain object from the chainId
     const chain = defineChain({
@@ -323,7 +323,7 @@ export async function getNativeTokenBalance(address: string, chainId: number): P
       balance: balance.value.toString(),
       metadata: {
         logoURI:
-          chainInfo?.icon?.url ||
+          chainInfo?.logoUrl ||
           "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/info/logo.png",
       },
       // Add native token info in extra_metadata

package/src/shared/utils/upload.ts

@@ -0,0 +1,48 @@
+const DEFAULT_UPLOADS_URL = "https://uploads.b3.fun";
+
+const ALLOWED_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+const MAX_FILE_SIZE = 5 * 1024 * 1024; // 5MB
+
+interface UploadResponse {
+  success: boolean;
+  data?: { url: string; filename: string; size: number; contentType: string };
+  error?: string;
+}
+
+interface UploadOptions {
+  baseUrl?: string;
+}
+
+/**
+ * Upload a file to the B3 uploads service (Cloudflare R2).
+ * Returns the public URL of the uploaded asset.
+ */
+export async function uploadFile(file: File, options?: UploadOptions): Promise<string> {
+  if (!ALLOWED_TYPES.includes(file.type)) {
+    throw new Error(`Invalid file type. Allowed: ${ALLOWED_TYPES.join(", ")}`);
+  }
+  if (file.size > MAX_FILE_SIZE) {
+    throw new Error(`File too large. Maximum size: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+  }
+
+  const uploadsUrl = options?.baseUrl || DEFAULT_UPLOADS_URL;
+  const formData = new FormData();
+  formData.append("file", file);
+
+  const res = await fetch(`${uploadsUrl}/upload/image`, {
+    method: "POST",
+    body: formData,
+  });
+
+  if (!res.ok) {
+    const body: UploadResponse = await res.json().catch(() => ({ success: false, error: "Upload failed" }));
+    throw new Error(body.error || `Upload failed (${res.status})`);
+  }
+
+  const body: UploadResponse = await res.json().catch(() => ({ success: false, error: "Invalid response" }));
+  if (!body.success || !body.data) {
+    throw new Error(body.error || "Upload failed");
+  }
+
+  return body.data.url;
+}