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

package/dist/cjs/global-account/react/hooks/useUnifiedChainSwitchAndExecute.d.ts

@@ -5,6 +5,7 @@ export interface UnifiedTransactionParams {
 }
 export declare function useUnifiedChainSwitchAndExecute(): {
     switchChainAndExecute: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
+    switchChainAndExecuteWithGlobalAccount: (targetChainId: number, params: UnifiedTransactionParams, expectedGlobalAccountAddress?: string) => Promise<string | undefined>;
     switchChainAndExecuteWithEOA: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
     isSwitchingOrExecuting: boolean;
     isActiveSmartWallet: boolean | undefined;

package/dist/cjs/global-account/react/hooks/useUnifiedChainSwitchAndExecute.js

@@ -15,13 +15,11 @@ const thirdweb_2 = require("thirdweb");
 const viem_1 = require("viem");
 const wagmi_1 = require("wagmi");
 const B3ConfigProvider_1 = require("../components/B3Provider/B3ConfigProvider");
-const useB3Account_1 = require("../components/B3Provider/useB3Account");
 const useAccountWallet_1 = require("./useAccountWallet");
 function useUnifiedChainSwitchAndExecute() {
     const { switchChainAsync } = (0, wagmi_1.useSwitchChain)();
     const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = (0, react_2.useState)(false);
-    const { isActiveSmartWallet, isActiveEOAWallet, connectedEOAWallet } = (0, useAccountWallet_1.useAccountWallet)();
-    const aaAccount = (0, useB3Account_1.useB3Account)();
+    const { isActiveSmartWallet, isActiveEOAWallet, connectedSmartWallet, connectedEOAWallet } = (0, useAccountWallet_1.useAccountWallet)();
     // From context, not process.env: partnerId is hashed into the server intent key and must match the ecosystem wallet.
     const { partnerId } = (0, B3ConfigProvider_1.useB3Config)();
     // Handle EOA wallet chain switch and execute transaction
@@ -100,10 +98,18 @@ function useUnifiedChainSwitchAndExecute() {
             setIsSwitchingOrExecuting(false);
         }
     }, [connectedEOAWallet, switchChainAsync]);
-    // Handle AA wallet transaction (no chain switch needed for AA)
-    const handleAASendTransaction = (0, react_2.useCallback)(async (targetChainId, params) => {
-        if (!aaAccount) {
-            react_1.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 = (0, react_2.useCallback)(async (targetChainId, params, expectedGlobalAccountAddress) => {
+        const globalAccount = connectedSmartWallet?.getAccount();
+        if (!globalAccount) {
+            react_1.toast.error("Global Account not connected");
+            return;
+        }
+        if (expectedGlobalAccountAddress &&
+            globalAccount.address.toLowerCase() !== expectedGlobalAccountAddress.toLowerCase()) {
+            react_1.toast.error("Connected Global Account does not match the authenticated account");
             return;
         }
         try {
@@ -137,7 +143,7 @@ function useUnifiedChainSwitchAndExecute() {
             react_1.toast.info("Sending transaction…");
             const start = performance.now();
             const sendTxResponse = await (0, thirdweb_2.sendTransaction)({
-                account: aaAccount,
+                account: globalAccount,
                 transaction,
             });
             const end = performance.now();
@@ -153,17 +159,18 @@ function useUnifiedChainSwitchAndExecute() {
         finally {
             setIsSwitchingOrExecuting(false);
         }
-    }, [aaAccount, partnerId]);
+    }, [connectedSmartWallet, partnerId]);
     // Unified switch chain and execute function
     const switchChainAndExecute = (0, react_2.useCallback)(async (targetChainId, params) => {
         // 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/dist/esm/global-account/react/hooks/useUnifiedChainSwitchAndExecute.d.ts

@@ -5,6 +5,7 @@ export interface UnifiedTransactionParams {
 }
 export declare function useUnifiedChainSwitchAndExecute(): {
     switchChainAndExecute: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
+    switchChainAndExecuteWithGlobalAccount: (targetChainId: number, params: UnifiedTransactionParams, expectedGlobalAccountAddress?: string) => Promise<string | undefined>;
     switchChainAndExecuteWithEOA: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
     isSwitchingOrExecuting: boolean;
     isActiveSmartWallet: boolean | undefined;

package/dist/esm/global-account/react/hooks/useUnifiedChainSwitchAndExecute.js

@@ -9,13 +9,11 @@ import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdw
 import { isAddress } from "viem";
 import { useSwitchChain } from "wagmi";
 import { useB3Config } from "../components/B3Provider/B3ConfigProvider.js";
-import { useB3Account } from "../components/B3Provider/useB3Account.js";
 import { useAccountWallet } from "./useAccountWallet.js";
 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
@@ -94,10 +92,18 @@ export function useUnifiedChainSwitchAndExecute() {
             setIsSwitchingOrExecuting(false);
         }
     }, [connectedEOAWallet, switchChainAsync]);
-    // Handle AA wallet transaction (no chain switch needed for AA)
-    const handleAASendTransaction = useCallback(async (targetChainId, params) => {
-        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, params, expectedGlobalAccountAddress) => {
+        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;
         }
         try {
@@ -131,7 +137,7 @@ export function useUnifiedChainSwitchAndExecute() {
             toast.info("Sending transaction…");
             const start = performance.now();
             const sendTxResponse = await twSendTransaction({
-                account: aaAccount,
+                account: globalAccount,
                 transaction,
             });
             const end = performance.now();
@@ -147,17 +153,18 @@ export function useUnifiedChainSwitchAndExecute() {
         finally {
             setIsSwitchingOrExecuting(false);
         }
-    }, [aaAccount, partnerId]);
+    }, [connectedSmartWallet, partnerId]);
     // Unified switch chain and execute function
     const switchChainAndExecute = useCallback(async (targetChainId, params) => {
         // 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/dist/types/global-account/react/hooks/useUnifiedChainSwitchAndExecute.d.ts

@@ -5,6 +5,7 @@ export interface UnifiedTransactionParams {
 }
 export declare function useUnifiedChainSwitchAndExecute(): {
     switchChainAndExecute: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
+    switchChainAndExecuteWithGlobalAccount: (targetChainId: number, params: UnifiedTransactionParams, expectedGlobalAccountAddress?: string) => Promise<string | undefined>;
     switchChainAndExecuteWithEOA: (targetChainId: number, params: UnifiedTransactionParams) => Promise<string | undefined>;
     isSwitchingOrExecuting: boolean;
     isActiveSmartWallet: boolean | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b3dotfun/sdk",
-  "version": "0.1.70-alpha.17",
+  "version": "0.1.70-alpha.18",
   "source": "src/index.ts",
   "main": "./dist/cjs/index.js",
   "react-native": "./dist/cjs/index.native.js",

package/src/global-account/react/hooks/__tests__/useUnifiedChainSwitchAndExecute.test.tsx

@@ -0,0 +1,156 @@
+import { act, renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useUnifiedChainSwitchAndExecute } from "../useUnifiedChainSwitchAndExecute";
+
+const mocks = vi.hoisted(() => ({
+  eoaGetAccount: vi.fn(),
+  globalAccountGetAccount: vi.fn(),
+  intentCreate: vi.fn(),
+  prepareTransaction: vi.fn(),
+  sendTransaction: vi.fn(),
+  toastError: vi.fn(),
+  toastInfo: vi.fn(),
+  toastSuccess: vi.fn(),
+  useAccountWallet: vi.fn(),
+}));
+
+vi.mock("@b3dotfun/sdk/anyspend", () => ({
+  getChainName: (chainId: number) => `Chain ${chainId}`,
+  getNativeToken: () => ({ name: "Ether", symbol: "ETH", decimals: 18 }),
+}));
+
+vi.mock("@b3dotfun/sdk/global-account/app", () => ({
+  default: {
+    service: () => ({ create: mocks.intentCreate }),
+  },
+}));
+
+vi.mock("@b3dotfun/sdk/global-account/react", () => ({
+  toast: {
+    dismiss: vi.fn(),
+    error: mocks.toastError,
+    info: mocks.toastInfo,
+    success: mocks.toastSuccess,
+  },
+}));
+
+vi.mock("@b3dotfun/sdk/shared/constants/chains/supported", () => ({
+  getThirdwebChain: (chainId: number) => ({ id: chainId }),
+  supportedChains: [],
+}));
+
+vi.mock("@b3dotfun/sdk/shared/utils/thirdweb", () => ({ client: {} }));
+
+vi.mock("thirdweb", () => ({
+  prepareTransaction: mocks.prepareTransaction,
+  sendTransaction: mocks.sendTransaction,
+}));
+
+vi.mock("viem", () => ({ isAddress: () => true }));
+
+vi.mock("wagmi", () => ({
+  useSwitchChain: () => ({ switchChainAsync: vi.fn() }),
+}));
+
+vi.mock("../../components/B3Provider/B3ConfigProvider", () => ({
+  useB3Config: () => ({ partnerId: "test-partner" }),
+}));
+
+vi.mock("../useAccountWallet", () => ({
+  useAccountWallet: mocks.useAccountWallet,
+}));
+
+const GLOBAL_ACCOUNT_ADDRESS = "0x1111111111111111111111111111111111111111";
+const OTHER_GLOBAL_ACCOUNT_ADDRESS = "0x2222222222222222222222222222222222222222";
+const EOA_ADDRESS = "0x3333333333333333333333333333333333333333";
+const TRANSACTION_HASH = `0x${"a".repeat(64)}`;
+
+const globalAccount = { address: GLOBAL_ACCOUNT_ADDRESS };
+const preparedTransaction = { prepared: true };
+const transactionParams = {
+  to: "0x4444444444444444444444444444444444444444",
+  data: "0x1234",
+  value: BigInt(0),
+};
+
+describe("useUnifiedChainSwitchAndExecute", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    mocks.globalAccountGetAccount.mockReturnValue(globalAccount);
+    mocks.eoaGetAccount.mockReturnValue({ address: EOA_ADDRESS });
+    mocks.intentCreate.mockResolvedValue({});
+    mocks.prepareTransaction.mockReturnValue(preparedTransaction);
+    mocks.sendTransaction.mockResolvedValue({ transactionHash: TRANSACTION_HASH });
+    mocks.useAccountWallet.mockReturnValue({
+      connectedSmartWallet: { getAccount: mocks.globalAccountGetAccount },
+      connectedEOAWallet: { getAccount: mocks.eoaGetAccount },
+      isActiveSmartWallet: false,
+      isActiveEOAWallet: true,
+    });
+  });
+
+  it("uses the connected Global Account even when the EOA wallet is active", async () => {
+    const { result } = renderHook(() => useUnifiedChainSwitchAndExecute());
+
+    let transactionHash: string | undefined;
+    await act(async () => {
+      transactionHash = await result.current.switchChainAndExecuteWithGlobalAccount(
+        8453,
+        transactionParams,
+        GLOBAL_ACCOUNT_ADDRESS,
+      );
+    });
+
+    expect(transactionHash).toBe(TRANSACTION_HASH);
+    expect(mocks.globalAccountGetAccount).toHaveBeenCalledOnce();
+    expect(mocks.eoaGetAccount).not.toHaveBeenCalled();
+    expect(mocks.sendTransaction).toHaveBeenCalledWith({
+      account: globalAccount,
+      transaction: preparedTransaction,
+    });
+  });
+
+  it("rejects a signer that does not match the authenticated Global Account", async () => {
+    const { result } = renderHook(() => useUnifiedChainSwitchAndExecute());
+
+    let transactionHash: string | undefined;
+    await act(async () => {
+      transactionHash = await result.current.switchChainAndExecuteWithGlobalAccount(
+        8453,
+        transactionParams,
+        OTHER_GLOBAL_ACCOUNT_ADDRESS,
+      );
+    });
+
+    expect(transactionHash).toBeUndefined();
+    expect(mocks.toastError).toHaveBeenCalledWith("Connected Global Account does not match the authenticated account");
+    expect(mocks.prepareTransaction).not.toHaveBeenCalled();
+    expect(mocks.sendTransaction).not.toHaveBeenCalled();
+    expect(mocks.eoaGetAccount).not.toHaveBeenCalled();
+  });
+
+  it("fails closed when no Global Account signer is connected", async () => {
+    mocks.useAccountWallet.mockReturnValue({
+      connectedSmartWallet: undefined,
+      connectedEOAWallet: { getAccount: mocks.eoaGetAccount },
+      isActiveSmartWallet: false,
+      isActiveEOAWallet: true,
+    });
+    const { result } = renderHook(() => useUnifiedChainSwitchAndExecute());
+
+    let transactionHash: string | undefined;
+    await act(async () => {
+      transactionHash = await result.current.switchChainAndExecuteWithGlobalAccount(
+        8453,
+        transactionParams,
+        GLOBAL_ACCOUNT_ADDRESS,
+      );
+    });
+
+    expect(transactionHash).toBeUndefined();
+    expect(mocks.toastError).toHaveBeenCalledWith("Global Account not connected");
+    expect(mocks.sendTransaction).not.toHaveBeenCalled();
+    expect(mocks.eoaGetAccount).not.toHaveBeenCalled();
+  });
+});

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

@@ -10,7 +10,6 @@ import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdw
 import { isAddress } from "viem";
 import { useSwitchChain } from "wagmi";
 import { useB3Config } from "../components/B3Provider/B3ConfigProvider";
-import { useB3Account } from "../components/B3Provider/useB3Account";
 import { useAccountWallet } from "./useAccountWallet";
 
 export interface UnifiedTransactionParams {
@@ -23,8 +22,7 @@ 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();
@@ -119,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;
       }
 
@@ -162,7 +175,7 @@ export function useUnifiedChainSwitchAndExecute() {
         toast.info("Sending transaction…");
         const start = performance.now();
         const sendTxResponse = await twSendTransaction({
-          account: aaAccount,
+          account: globalAccount,
           transaction,
         });
         const end = performance.now();
@@ -178,7 +191,7 @@ export function useUnifiedChainSwitchAndExecute() {
         setIsSwitchingOrExecuting(false);
       }
     },
-    [aaAccount, partnerId],
+    [connectedSmartWallet, partnerId],
   );
 
   // Unified switch chain and execute function
@@ -186,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,