@b3dotfun/sdk 0.1.69 → 0.1.70-alpha.2

package/src/global-account/react/utils/createWagmiConfig.tsx

@@ -1,9 +1,8 @@
+import { createWalletConfig } from "@b3dotfun/sdk/wallet/utils/createWalletConfig";
 import { ecosystemWalletId } from "@b3dotfun/sdk/shared/constants";
-import { supportedChains } from "@b3dotfun/sdk/shared/constants/chains/supported";
 import { client } from "@b3dotfun/sdk/shared/utils/thirdweb";
 import { inAppWalletConnector } from "@thirdweb-dev/wagmi-adapter";
-import { http } from "viem";
-import { createConfig, type CreateConnectorFn } from "wagmi";
+import type { CreateConnectorFn } from "wagmi";
 
 export interface CreateWagmiConfigOptions {
   partnerId: string;
@@ -13,7 +12,8 @@ export interface CreateWagmiConfigOptions {
 }
 
 /**
- * Creates a wagmi config with optional custom RPC URLs and connectors
+ * Creates a wagmi config with the B3 ecosystem wallet connector.
+ * Delegates to createWalletConfig and adds the ecosystem connector on top.
  * @param options.partnerId - Partner ID for the ecosystem wallet
  * @param options.rpcUrls - Optional mapping of chain IDs to RPC URLs
  * @param options.connectors - Additional connectors to include
@@ -32,27 +32,8 @@ export function createWagmiConfig(options: CreateWagmiConfigOptions) {
 
   const finalConnectors = overrideDefaultConnectors ? connectors : [...defaultConnectors, ...connectors];
 
-  return createConfig({
-    chains: [supportedChains[0], ...supportedChains.slice(1)],
-    transports: Object.fromEntries(supportedChains.map(chain => [chain.id, http(rpcUrls?.[chain.id])])),
+  return createWalletConfig({
     connectors: finalConnectors,
+    rpcUrls,
   });
 }
-
-/** Module-level cache — wagmi configs must not be recreated on every render. */
-const wagmiConfigCache = new Map<string, ReturnType<typeof createWagmiConfig>>();
-
-/**
- * Returns a cached wagmi config for the given partnerId.
- * Use this instead of calling createWagmiConfig() directly inside React components or hooks
- * to avoid registering duplicate EventEmitter listeners on every render.
- */
-export function getCachedWagmiConfig(options: CreateWagmiConfigOptions) {
-  const key = options.partnerId;
-  let config = wagmiConfigCache.get(key);
-  if (!config) {
-    config = createWagmiConfig(options);
-    wagmiConfigCache.set(key, config);
-  }
-  return config;
-}

package/src/global-account/react/utils/index.ts

@@ -1,4 +1,3 @@
 export * from "./notificationsAPI";
 export * from "./profileDisplay";
 export * from "./toast";
-export * from "./updateAvatar";

package/src/global-account/react/utils/profileDisplay.ts

@@ -3,6 +3,21 @@ import { type Profile } from "thirdweb/wallets";
 
 const debug = debugB3React("profileDisplay");
 
+const ALLOWED_IPFS_GATEWAYS = [
+  "ipfs.io",
+  "gateway.pinata.cloud",
+  "cloudflare-ipfs.com",
+  "dweb.link",
+  "nftstorage.link",
+  "w3s.link",
+];
+
+const BLOCKED_HOSTNAMES = ["models.readyplayer.me", "readyplayer.me"];
+
+function isHostnameInList(hostname: string, list: string[]): boolean {
+  return list.some(entry => hostname === entry || hostname.endsWith(`.${entry}`));
+}
+
 /**
  * Validates that an image URL uses an allowed schema
  * @param url - The URL to validate
@@ -31,30 +46,17 @@ export function validateImageUrl(url: string | null | undefined): string | null
       return null;
     }
 
-    // Whitelist of allowed IPFS gateway hostnames
-    const allowedIpfsGateways = [
-      "ipfs.io",
-      "gateway.pinata.cloud",
-      "cloudflare-ipfs.com",
-      "dweb.link",
-      "nftstorage.link",
-      "w3s.link",
-    ];
-
-    // Check if hostname matches allowed IPFS gateways
     const hostname = parsedUrl.hostname.toLowerCase();
-    const isAllowedIpfsGateway = allowedIpfsGateways.some(gateway => {
-      // Exact match or subdomain of the gateway
-      return hostname === gateway || hostname.endsWith(`.${gateway}`);
-    });
 
-    if (isAllowedIpfsGateway) {
+    if (isHostnameInList(hostname, ALLOWED_IPFS_GATEWAYS)) {
       return url;
     }
 
-    // For standard HTTP(S) URLs from trusted sources
-    // Add additional hostname validation here if needed
-    // For now, allow all HTTP(S) URLs (can be restricted further if needed)
+    if (isHostnameInList(hostname, BLOCKED_HOSTNAMES)) {
+      debug("Rejected deprecated avatar service:", hostname, url);
+      return null;
+    }
+
     return url;
   } catch (error) {
     // Invalid URL format

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

@@ -1,6 +1,6 @@
+import { ChainNetworks } from "@b3dotfun/sdk/global-account/types/chain-networks";
 import { defineChain as defineThirdwebChain, Chain as ThirdwebChain } from "thirdweb";
 import { Chain, defineChain } from "viem";
-import { ChainNetworks } from "@b3dotfun/sdk/global-account/types/chain-networks";
 
 export const nullAddress = "0x0000000000000000000000000000000000000000";
 
@@ -58,11 +58,11 @@ export const b3Testnet: Chain = defineChain({
 export const b3Mainnet = defineChain({
   id: 8333,
   name: "B3",
-  rpc: "https://mainnet-rpc.b3.fun",
+  rpc: "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2",
   rpcUrls: {
     default: {
-      http: ["https://mainnet-rpc.b3.fun"],
-      ws: ["wss://mainnet-rpc.b3.fun/ws"],
+      http: ["https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"],
+      ws: ["wss://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2"],
     },
   },
   icon: {
@@ -133,7 +133,7 @@ export const thirdwebB3Testnet: ThirdwebChain = defineThirdwebChain({
 export const thirdwebB3Mainnet: ThirdwebChain = defineThirdwebChain({
   id: 8333,
   name: "B3",
-  rpc: "https://mainnet-rpc.b3.fun/http",
+  rpc: "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2/",
   icon: {
     url: "https://cdn.b3.fun/b3_logo.svg",
     width: 32,

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

@@ -0,0 +1,18 @@
+import { B3_PUBLIC_RPC } from "@b3dotfun/sdk/anyspend/constants/rpc";
+import type { Chain } from "viem";
+import { b3 as viemB3 } from "viem/chains";
+
+/**
+ * Viem's built-in `b3` chain points at mainnet-rpc.b3.fun; we spread it and override
+ * RPC URLs so all SDK call sites stay aligned with {@link B3_PUBLIC_RPC}.
+ */
+export const b3Viem: Chain = {
+  ...viemB3,
+  rpcUrls: {
+    ...viemB3.rpcUrls,
+    default: {
+      ...viemB3.rpcUrls.default,
+      http: [B3_PUBLIC_RPC],
+    },
+  },
+};

package/src/shared/constants/index.ts

@@ -32,3 +32,5 @@ export const B3_AUTH_COOKIE_NAME = "b3-auth";
 export const ENS_GATEWAY_URL = "https://ens-gateway.b3.fun/";
 
 export const PUBLIC_BASE_RPC_URL = "https://base-rpc.publicnode.com";
+
+export const AVATAR_COLORS = ["#3368ef", "#272727", "#6366f1", "#06b6d4", "#eeb0d9", "#ba3fbf", "#ff777b", "#dfbb53"];

package/src/shared/generated/chain-networks.json

@@ -5,8 +5,8 @@
     "name": "B3",
     "rpcUrls": {
       "default": {
-        "http": "https://mainnet-rpc.b3.fun",
-        "ws": "wss://mainnet-rpc.b3.fun/ws"
+        "http": "https://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2/",
+        "ws": "wss://late-dimensional-yard.b3-mainnet.quiknode.pro/461dbdbd44158cd7a7a764a58ffb01a67eef77f2/"
       },
       "backups": []
     },

package/src/shared/utils/chains.ts

@@ -1,5 +1,6 @@
+import { b3Viem } from "@b3dotfun/sdk/shared/constants/chains/b3Viem";
 import { supportedChains } from "@b3dotfun/sdk/shared/constants/chains/supported";
-import { b3, Chain } from "viem/chains";
+import type { Chain } from "viem";
 
 const baseChainBaseUrl = "https://basescan.org";
 
@@ -13,7 +14,7 @@ export function chainIdToName(id: number) {
 }
 
 export function getExplorerUrl(chain: Chain, txHash: string): string {
-  if (chain.id === b3.id) {
+  if (chain.id === b3Viem.id) {
     return "https://explorer.b3.fun/b3/tx/" + txHash;
   }
   let baseUrl = chain.blockExplorers?.default.url;

package/src/shared/utils/session-duration.ts

@@ -0,0 +1,64 @@
+const STORAGE_KEY_PREFIX = "b3-session-duration";
+const DEFAULT_DAYS = 7;
+
+// 0 = session cookie (expires when browser closes)
+export const SESSION_DURATION_OPTIONS = [0, 1, 7, 14, 30] as const;
+export type SessionDurationDays = (typeof SESSION_DURATION_OPTIONS)[number];
+
+function storageKey(partnerId?: string) {
+  return partnerId ? `${STORAGE_KEY_PREFIX}_${partnerId}` : STORAGE_KEY_PREFIX;
+}
+
+/**
+ * Read session duration for a specific partner.
+ *
+ * preferences shape: { [partnerId]: { sessionDuration: number }, sessionDuration?: number }
+ *
+ * Priority: user.preferences[partnerId].sessionDuration
+ *           → user.preferences.sessionDuration (global fallback)
+ *           → localStorage (per-partner) → localStorage (global) → default 7d
+ */
+export function getSessionDurationDays(userPreferences?: Record<string, any>, partnerId?: string): SessionDurationDays {
+  if (userPreferences) {
+    if (partnerId) {
+      const v = userPreferences[partnerId]?.sessionDuration;
+      if (SESSION_DURATION_OPTIONS.includes(v as SessionDurationDays)) return v as SessionDurationDays;
+    }
+    const v = userPreferences["sessionDuration"];
+    if (SESSION_DURATION_OPTIONS.includes(v as SessionDurationDays)) return v as SessionDurationDays;
+  }
+  try {
+    if (partnerId) {
+      const stored = localStorage.getItem(storageKey(partnerId));
+      if (stored !== null) {
+        const parsed = Number(stored);
+        if (SESSION_DURATION_OPTIONS.includes(parsed as SessionDurationDays)) return parsed as SessionDurationDays;
+      }
+    }
+    const stored = localStorage.getItem(STORAGE_KEY_PREFIX);
+    if (stored !== null) {
+      const parsed = Number(stored);
+      if (SESSION_DURATION_OPTIONS.includes(parsed as SessionDurationDays)) return parsed as SessionDurationDays;
+    }
+  } catch {
+    // localStorage unavailable (e.g. SSR)
+  }
+  return DEFAULT_DAYS;
+}
+
+export const SESSION_DURATION_LABELS: Record<SessionDurationDays, string> = {
+  0: "Session only",
+  1: "1 day",
+  7: "7 days",
+  14: "14 days",
+  30: "30 days",
+};
+
+/** Cache the preference locally so it's available immediately on next login */
+export function setSessionDurationDays(days: SessionDurationDays, partnerId?: string): void {
+  try {
+    localStorage.setItem(storageKey(partnerId), String(days));
+  } catch {
+    // ignore
+  }
+}

package/src/types/torph.d.ts

@@ -0,0 +1,4 @@
+declare module "torph/react" {
+  import type { JSX } from "react";
+  export function TextMorph(props: { children: string; className?: string }): JSX.Element;
+}

package/src/wallet/__tests__/createWalletConfig.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { createWalletConfig } from "../utils/createWalletConfig";
+import { base, optimism } from "viem/chains";
+
+describe("createWalletConfig", () => {
+  it("should create a config with default chains when no options provided", () => {
+    const config = createWalletConfig();
+    // Should not throw — uses supportedChains as default
+    expect(config).toBeDefined();
+    expect(config.chains).toBeDefined();
+    expect(config.chains.length).toBeGreaterThan(0);
+  });
+
+  it("should create a config with custom chains", () => {
+    const config = createWalletConfig({ chains: [base, optimism] });
+    expect(config.chains).toHaveLength(2);
+    expect(config.chains[0].id).toBe(base.id);
+    expect(config.chains[1].id).toBe(optimism.id);
+  });
+
+  it("should throw if chains array is empty", () => {
+    expect(() => createWalletConfig({ chains: [] })).toThrow("createWalletConfig: at least one chain must be provided");
+  });
+
+  it("should accept custom RPC URLs", () => {
+    const config = createWalletConfig({
+      chains: [base],
+      rpcUrls: { [base.id]: "https://custom-rpc.example.com" },
+    });
+    expect(config).toBeDefined();
+    // Config is created without error; transport internals are opaque
+  });
+
+  it("should accept connectors", () => {
+    // Pass an empty array (valid) — connector instantiation requires browser env
+    const config = createWalletConfig({ chains: [base], connectors: [] });
+    expect(config).toBeDefined();
+  });
+});