@b3dotfun/sdk 0.0.37 → 0.0.38

package/dist/types/global-account/react/components/B3Provider/B3Provider.native.d.ts

@@ -1,22 +1,25 @@
 import { PermissionsConfig } from "@b3dotfun/sdk/global-account/types/permissions";
 import { Account } from "thirdweb/wallets";
+import { ClientType } from "../../../client-manager";
 import { B3ContextType } from "./types";
 /**
  * Main B3Provider component
  */
-export declare function B3Provider({ theme, children, accountOverride, environment, }: {
+export declare function B3Provider({ theme, children, accountOverride, environment, clientType, }: {
     theme: "light" | "dark";
     children: React.ReactNode;
     accountOverride?: Account;
     environment: B3ContextType["environment"];
+    clientType?: ClientType;
 }): import("react/jsx-runtime").JSX.Element;
 /**
  * Inner provider component that provides the actual B3Context
  */
-export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, theme, }: {
+export declare function InnerProvider({ children, accountOverride, environment, defaultPermissions, theme, clientType, }: {
     children: React.ReactNode;
     accountOverride?: Account;
     environment: B3ContextType["environment"];
     defaultPermissions?: PermissionsConfig;
     theme: "light" | "dark";
+    clientType?: ClientType;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/types/global-account/react/components/B3Provider/types.d.ts

@@ -1,6 +1,7 @@
 import { Users } from "@b3dotfun/b3-api";
 import { PermissionsConfig } from "@b3dotfun/sdk/global-account/types/permissions";
 import { Account, Wallet } from "thirdweb/wallets";
+import { ClientType } from "../../../client-manager";
 /**
  * Context type for B3Provider
  */
@@ -16,6 +17,7 @@ export interface B3ContextType {
     environment?: "development" | "production";
     defaultPermissions?: PermissionsConfig;
     theme: "light" | "dark";
+    clientType: ClientType;
 }
 /**
  * Context for B3 provider

package/dist/types/global-account/react/hooks/index.d.ts

@@ -8,6 +8,7 @@ export { useB3EnsName } from "./useB3EnsName";
 export { useBestTransactionPath } from "./useBestTransactionPath";
 export { useChainSwitchWithAction } from "./useChainSwitchWithAction";
 export * from "./useClaim";
+export { useClient } from "./useClient";
 export { useConnect } from "./useConnect";
 export { useExchangeRate } from "./useExchangeRate";
 export { useFirstEOA } from "./useFirstEOA";

package/dist/types/global-account/react/hooks/useClient.d.ts

@@ -0,0 +1,16 @@
+import { ClientType } from "../../client-manager";
+/**
+ * Hook to access the current FeathersJS client and client management utilities
+ */
+export declare function useClient(): {
+    clientType: ClientType;
+    getCurrentClient: () => import("@b3dotfun/b3-api").ClientApplication;
+    getClientByType: (type: ClientType) => import("@b3dotfun/b3-api").ClientApplication;
+    switchClientType: (type: ClientType) => void;
+    authenticateWithType: (type: ClientType, accessToken: string, identityToken: string, params?: Record<string, any>) => Promise<import("@feathersjs/authentication").AuthenticationResult | null>;
+    authenticateWithBoth: (accessToken: string, identityToken: string, params?: Record<string, any>) => Promise<{
+        socket: import("@feathersjs/authentication").AuthenticationResult | null;
+        rest: import("@feathersjs/authentication").AuthenticationResult | null;
+        success: boolean;
+    }>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.0.37",
+  "version": "0.0.38",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",
@@ -242,6 +242,7 @@
     "@feathersjs/authentication-client": "5.0.33",
     "@feathersjs/feathers": "5.0.33",
     "@feathersjs/socketio-client": "5.0.33",
+    "@feathersjs/rest-client": "5.0.33",
     "@feathersjs/typebox": "5.0.33",
     "@fingerprintjs/fingerprintjs-pro-react": "^2.7.0",
     "@hey-api/client-fetch": "0.8.3",

package/src/app.shared.ts

@@ -0,0 +1,61 @@
+import { ClientApplication } from "@b3dotfun/b3-api";
+import { AuthenticationClient } from "@feathersjs/authentication-client";
+import Cookies from "js-cookie";
+import { B3_AUTH_COOKIE_NAME } from "./shared/constants";
+
+export const B3_API_URL =
+  process.env.EXPO_PUBLIC_B3_API || process.env.NEXT_PUBLIC_B3_API || process.env.PUBLIC_B3_API || "https://api.b3.fun";
+
+export const authenticate = async (
+  app: ClientApplication,
+  accessToken: string,
+  identityToken: string,
+  params?: Record<string, any>,
+) => {
+  const fullToken = `${accessToken}+${identityToken}`;
+
+  // Do not authenticate if there is no token
+  if (!fullToken) {
+    console.log("No token found, not authenticating");
+    return null;
+  }
+
+  try {
+    const response = await app.authenticate(
+      {
+        strategy: "jwt",
+        accessToken: fullToken,
+      },
+      {
+        query: params || {},
+      },
+    );
+    return response;
+  } catch (error) {
+    return null;
+  }
+};
+
+export class MyAuthenticationClient extends AuthenticationClient {
+  getFromLocation(location: any) {
+    // Do custom location things here
+    return super.getFromLocation(location);
+  }
+}
+
+export const clientOptions = {
+  Authentication: MyAuthenticationClient,
+  jwtStrategy: "jwt",
+  storage: {
+    getItem: (key: string) => {
+      return Cookies.get(key);
+    },
+    setItem: (key: string, value: string) => {
+      Cookies.set(key, value);
+    },
+    removeItem: (key: string) => {
+      Cookies.remove(key);
+    },
+  },
+  storageKey: B3_AUTH_COOKIE_NAME,
+};

package/src/global-account/app.rest.ts

@@ -0,0 +1,4 @@
+import { getClientByType } from "./client-manager";
+
+export { authenticateWithClient, getClientByType, getClientType, setClientType } from "./client-manager";
+export const getRestClient = () => getClientByType("rest");

package/src/global-account/app.ts

@@ -1,68 +1,22 @@
-import { createClient } from "@b3dotfun/b3-api";
-import { AuthenticationClient } from "@feathersjs/authentication-client";
-import socketio from "@feathersjs/socketio-client";
-import Cookies from "js-cookie";
-import io from "socket.io-client";
-import { B3_AUTH_COOKIE_NAME } from "../shared/constants";
+import type { ClientApplication } from "@b3dotfun/b3-api";
+import { authenticate, getClient, getClientByType, setClientType } from "./client-manager";
 
-const B3_API_URL =
-  process.env.EXPO_PUBLIC_B3_API || process.env.NEXT_PUBLIC_B3_API || process.env.PUBLIC_B3_API || "https://api.b3.fun";
+// Default to rest
+setClientType("rest");
 
-const socket = io(B3_API_URL, { transports: ["websocket"] });
-
-class MyAuthenticationClient extends AuthenticationClient {
-  getFromLocation(location: any) {
-    // Do custom location things here
-    return super.getFromLocation(location);
-  }
-}
-
-const app = createClient(socketio(socket), {
-  Authentication: MyAuthenticationClient,
-  jwtStrategy: "jwt",
-  storage: {
-    getItem: (key: string) => {
-      return Cookies.get(key);
-    },
-    setItem: (key: string, value: string) => {
-      Cookies.set(key, value);
-    },
-    removeItem: (key: string) => {
-      Cookies.remove(key);
-    },
+// Default export that *looks like* a Feathers app and auto-forwards
+const app = new Proxy({} as ClientApplication, {
+  get(_t, prop, receiver) {
+    const target = getClient() as any;
+    return Reflect.get(target, prop, receiver);
   },
-  storageKey: B3_AUTH_COOKIE_NAME,
-});
-
-export const authenticate = async (accessToken: string, identityToken: string, params?: Record<string, any>) => {
-  const fullToken = `${accessToken}+${identityToken}`;
-
-  // Do not authenticate if there is no token
-  if (!fullToken) {
-    console.log("No token found, not authenticating");
-    return null;
-  }
-
-  try {
-    const response = await app.authenticate(
-      {
-        strategy: "jwt",
-        accessToken: fullToken,
-      },
-      {
-        query: params || {},
-      },
-    );
-    return response;
-  } catch (error) {
-    return null;
-  }
-};
-
-export const resetSocket = () => {
-  if (socket.connected) socket.disconnect();
-  socket.connect();
-  // reset the socket connection
-};
+  set(_t, prop, value) {
+    const target = getClient() as any;
+    return Reflect.set(target, prop, value);
+  },
+}) as ClientApplication;
 
 export default app;
+
+// Power-user helpers (named exports)
+export { authenticate, getClient, getClientByType, setClientType };

package/src/global-account/client-manager.ts

@@ -0,0 +1,141 @@
+import { ClientApplication, createClient } from "@b3dotfun/b3-api";
+import rest from "@feathersjs/rest-client";
+import socketio from "@feathersjs/socketio-client";
+import io from "socket.io-client";
+import { authenticate as authenticateB3, B3_API_URL, clientOptions } from "../app.shared";
+
+export type ClientType = "socket" | "rest";
+
+// Global state to track which client type is active
+let currentClientType: ClientType = "rest";
+let currentClient: ClientApplication | null = null;
+
+// Socket client instance
+let socketClient: ClientApplication | null = null;
+let socketInstance: any = null;
+
+// REST client instance
+let restClient: ClientApplication | null = null;
+
+/**
+ * Creates a socket client
+ */
+function createSocketClient(): ClientApplication {
+  if (!socketClient) {
+    socketInstance = io(B3_API_URL, { transports: ["websocket"] });
+    socketClient = createClient(socketio(socketInstance), clientOptions);
+  }
+  return socketClient;
+}
+
+/**
+ * Creates a REST client
+ */
+function resolveFetch(): typeof fetch {
+  const f = (globalThis as any).fetch;
+  if (typeof f === "function") return f.bind(globalThis);
+  // lazy-require for Node environments
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require("cross-fetch").fetch as typeof fetch;
+}
+
+function createRestClient(): ClientApplication {
+  if (!restClient) {
+    const connection = rest(B3_API_URL).fetch(resolveFetch());
+    restClient = createClient(connection, clientOptions);
+  }
+  return restClient;
+}
+
+/**
+ * Sets the active client type and creates the appropriate client
+ *
+ * Note: When using, be sure to avoid race conditions between different clients
+ */
+export function setClientType(t: ClientType): void {
+  if (currentClientType === t && currentClient) return;
+  currentClientType = t;
+  currentClient = t === "socket" ? createSocketClient() : createRestClient();
+}
+
+/**
+ * Gets the current active client
+ */
+export function getClient(): ClientApplication {
+  if (!currentClient) {
+    currentClient = currentClientType === "socket" ? createSocketClient() : createRestClient();
+  }
+  return currentClient;
+}
+
+/**
+ * Gets the current client type
+ */
+export function getClientType(): ClientType {
+  return currentClientType;
+}
+
+/**
+ * Gets a specific client type (useful for parallel operations)
+ */
+export function getClientByType(clientType: ClientType): ClientApplication {
+  if (clientType === "socket") {
+    return createSocketClient();
+  } else {
+    return createRestClient();
+  }
+}
+
+/**
+ * Resets the socket connection (only applicable for socket client)
+ */
+export function resetSocket(): void {
+  if (socketInstance && socketInstance.connected) {
+    socketInstance.disconnect();
+    socketInstance.connect();
+  }
+}
+
+/**
+ * Authenticates with the current active client
+ */
+export const authenticate = async (accessToken: string, identityToken: string, params?: Record<string, any>) => {
+  return authenticateB3(getClient(), accessToken, identityToken, params);
+};
+
+/**
+ * Authenticates with a specific client type
+ */
+export const authenticateWithClient = async (
+  clientType: ClientType,
+  accessToken: string,
+  identityToken: string,
+  params?: Record<string, any>,
+) => {
+  const client = getClientByType(clientType);
+  return authenticateB3(client, accessToken, identityToken, params);
+};
+
+/**
+ * Authenticates with both clients in parallel (useful for migration scenarios)
+ */
+export const authenticateBoth = async (accessToken: string, identityToken: string, params?: Record<string, any>) => {
+  const [socketResult, restResult] = await Promise.allSettled([
+    authenticateWithClient("socket", accessToken, identityToken, params),
+    authenticateWithClient("rest", accessToken, identityToken, params),
+  ]);
+
+  return {
+    socket: socketResult.status === "fulfilled" ? socketResult.value : null,
+    rest: restResult.status === "fulfilled" ? restResult.value : null,
+    success: socketResult.status === "fulfilled" || restResult.status === "fulfilled",
+  };
+};
+
+/**
+ * Switches the client type and authenticates
+ */
+export async function switchClientAndAuth(type: ClientType, access: string, id: string, params?: any) {
+  setClientType(type);
+  return authenticateWithClient(type, access, id, params);
+}

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

@@ -5,6 +5,8 @@ import { ThirdwebProvider, useActiveAccount } from "thirdweb/react";
 import { Account } from "thirdweb/wallets";
 
 import { Users } from "@b3dotfun/b3-api";
+import { ClientType } from "../../../client-manager";
+
 import { B3Context, B3ContextType } from "./types";
 
 /**
@@ -28,16 +30,23 @@ export function B3Provider({
   children,
   accountOverride,
   environment,
+  clientType = "socket",
 }: {
   theme: "light" | "dark";
   children: React.ReactNode;
   accountOverride?: Account;
   environment: B3ContextType["environment"];
+  clientType?: ClientType;
 }) {
   return (
     <QueryClientProvider client={queryClient}>
       <ThirdwebProvider>
-        <InnerProvider accountOverride={accountOverride} environment={environment} theme={theme}>
+        <InnerProvider
+          accountOverride={accountOverride}
+          environment={environment}
+          theme={theme}
+          clientType={clientType}
+        >
           {/* <RelayKitProviderWrapper> */}
           {children}
           {/* </RelayKitProviderWrapper> */}
@@ -56,12 +65,14 @@ export function InnerProvider({
   environment,
   defaultPermissions = DEFAULT_PERMISSIONS,
   theme = "light",
+  clientType = "socket",
 }: {
   children: React.ReactNode;
   accountOverride?: Account;
   environment: B3ContextType["environment"];
   defaultPermissions?: PermissionsConfig;
   theme: "light" | "dark";
+  clientType?: ClientType;
 }) {
   const activeAccount = useActiveAccount();
   const [user, setUser] = useState<Users | undefined>(undefined);
@@ -83,6 +94,7 @@ export function InnerProvider({
         environment,
         defaultPermissions,
         theme,
+        clientType,
       }}
     >
       {children}

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

@@ -14,6 +14,7 @@ import {
 } from "thirdweb/react";
 import { Account, Wallet } from "thirdweb/wallets";
 import { createConfig, http, WagmiProvider } from "wagmi";
+import { ClientType, setClientType } from "../../../client-manager";
 import { StyleRoot } from "../StyleRoot";
 import { B3Context, B3ContextType } from "./types";
 
@@ -49,6 +50,7 @@ export function B3Provider({
   automaticallySetFirstEoa,
   simDuneApiKey,
   toaster,
+  clientType = "rest",
 }: {
   theme: "light" | "dark";
   children: React.ReactNode;
@@ -60,12 +62,18 @@ export function B3Provider({
     position?: "top-center" | "top-right" | "bottom-center" | "bottom-right";
     style?: React.CSSProperties;
   };
+  clientType?: ClientType;
 }) {
   // Initialize Google Analytics on mount
   useEffect(() => {
     loadGA4Script();
   }, []);
 
+  // Set the client type when provider mounts
+  useEffect(() => {
+    setClientType(clientType);
+  }, [clientType]);
+
   return (
     <WagmiProvider config={wagmiConfig}>
       <QueryClientProvider client={queryClient}>
@@ -76,6 +84,7 @@ export function B3Provider({
               environment={environment}
               theme={theme}
               automaticallySetFirstEoa={!!automaticallySetFirstEoa}
+              clientType={clientType}
             >
               <RelayKitProviderWrapper simDuneApiKey={simDuneApiKey}>
                 {children}
@@ -101,6 +110,7 @@ export function InnerProvider({
   defaultPermissions = DEFAULT_PERMISSIONS,
   automaticallySetFirstEoa,
   theme = "light",
+  clientType = "socket",
 }: {
   children: React.ReactNode;
   accountOverride?: Account;
@@ -108,6 +118,7 @@ export function InnerProvider({
   defaultPermissions?: PermissionsConfig;
   automaticallySetFirstEoa: boolean;
   theme: "light" | "dark";
+  clientType?: ClientType;
 }) {
   const activeAccount = useActiveAccount();
   const [manuallySelectedWallet, setManuallySelectedWallet] = useState<Wallet | undefined>(undefined);
@@ -192,6 +203,7 @@ export function InnerProvider({
         environment,
         defaultPermissions,
         theme,
+        clientType,
       }}
     >
       {children}

package/src/global-account/react/components/B3Provider/types.ts

@@ -2,6 +2,7 @@ import { Users } from "@b3dotfun/b3-api";
 import { PermissionsConfig } from "@b3dotfun/sdk/global-account/types/permissions";
 import { createContext } from "react";
 import { Account, Wallet } from "thirdweb/wallets";
+import { ClientType } from "../../../client-manager";
 
 /**
  * Context type for B3Provider
@@ -18,6 +19,7 @@ export interface B3ContextType {
   environment?: "development" | "production";
   defaultPermissions?: PermissionsConfig;
   theme: "light" | "dark";
+  clientType: ClientType;
 }
 
 /**
@@ -34,4 +36,5 @@ export const B3Context = createContext<B3ContextType>({
   ready: false,
   environment: "development",
   theme: "light",
+  clientType: "rest",
 });

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

@@ -8,6 +8,7 @@ export { useB3EnsName } from "./useB3EnsName";
 export { useBestTransactionPath } from "./useBestTransactionPath";
 export { useChainSwitchWithAction } from "./useChainSwitchWithAction";
 export * from "./useClaim";
+export { useClient } from "./useClient";
 export { useConnect } from "./useConnect";
 export { useExchangeRate } from "./useExchangeRate";
 export { useFirstEOA } from "./useFirstEOA";

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

@@ -0,0 +1,57 @@
+import { useB3 } from "@b3dotfun/sdk/global-account/react";
+import { useCallback } from "react";
+import {
+  ClientType,
+  authenticateBoth,
+  authenticateWithClient,
+  getClient,
+  getClientByType,
+  setClientType,
+} from "../../client-manager";
+
+/**
+ * Hook to access the current FeathersJS client and client management utilities
+ */
+export function useClient() {
+  const { clientType } = useB3();
+
+  const getCurrentClient = useCallback(() => {
+    return getClient();
+  }, []);
+
+  const getClientByTypeCallback = useCallback((type: ClientType) => {
+    return getClientByType(type);
+  }, []);
+
+  const switchClientType = useCallback((type: ClientType) => {
+    setClientType(type);
+  }, []);
+
+  const authenticateWithType = useCallback(
+    async (type: ClientType, accessToken: string, identityToken: string, params?: Record<string, any>) => {
+      return authenticateWithClient(type, accessToken, identityToken, params);
+    },
+    [],
+  );
+
+  const authenticateWithBoth = useCallback(
+    async (accessToken: string, identityToken: string, params?: Record<string, any>) => {
+      return authenticateBoth(accessToken, identityToken, params);
+    },
+    [],
+  );
+
+  return {
+    // Current client info
+    clientType,
+    getCurrentClient,
+
+    // Client management
+    getClientByType: getClientByTypeCallback,
+    switchClientType,
+
+    // Authentication utilities
+    authenticateWithType,
+    authenticateWithBoth,
+  };
+}