useSendSCWTransactions

src/transaction/components/TransactionProvider.tsx

@@ -21,13 +21,12 @@ import { useValue } from '../../internal/hooks/useValue';
 import {
   GENERIC_ERROR_MESSAGE,
   METHOD_NOT_SUPPORTED_ERROR_SUBSTRING,
-  TRANSACTION_TYPE_CALLS,
-  TRANSACTION_TYPE_CONTRACTS,
 } from '../constants';
 import { useCallsStatus } from '../hooks/useCallsStatus';
 import { useSendCall } from '../hooks/useSendCall';
 import { useSendCalls } from '../hooks/useSendCalls';
 import { useSendEOATransactions } from '../hooks/useSendEOATransactions';
+import { useSendSCWTransactions } from '../hooks/useSendSCWTransactions';
 import { useTransactionStatus } from '../hooks/useTransactionStatus';
 import { useTransactionType } from '../hooks/useTransactionType';
 import { useWriteContract } from '../hooks/useWriteContract';
@@ -193,30 +192,17 @@ export function TransactionProvider({
   );
 
   /* 
-    Execute batched transactions using the experimental hooks.
+    Execute batched transactions using Wagmi experimental hooks.
     Based off the transaction type (either contract functions or calls)
   */
-  const executeBatchedTransactions = useCallback(async () => {
-    if (transactionType === TRANSACTION_TYPE_CONTRACTS && contracts) {
-      await writeContractsAsync({
-        contracts,
-        capabilities,
-      });
-    }
-    if (transactionType === TRANSACTION_TYPE_CALLS && calls) {
-      await sendCallsAsync({
-        calls,
-        capabilities,
-      });
-    }
-  }, [
-    writeContractsAsync,
-    sendCallsAsync,
-    calls,
+  const sendSCWTransactions = useSendSCWTransactions({
+    transactionType,
     contracts,
+    calls,
     capabilities,
-    transactionType,
-  ]);
+    writeContractsAsync,
+    sendCallsAsync,
+  });
 
   const handleSubmitErrors = useCallback(
     async (err: unknown) => {
@@ -250,11 +236,11 @@ export function TransactionProvider({
     setIsToastVisible(true);
     try {
       await switchChain(chainId);
-      await executeBatchedTransactions();
+      await sendSCWTransactions();
     } catch (err) {
       await handleSubmitErrors(err);
     }
-  }, [chainId, executeBatchedTransactions, handleSubmitErrors, switchChain]);
+  }, [chainId, sendSCWTransactions, handleSubmitErrors, switchChain]);
 
   useEffect(() => {
     if (receiptArray?.length) {

src/transaction/hooks/useSendSCWTransactions.test.tsx

@@ -0,0 +1,118 @@
+import { renderHook } from '@testing-library/react';
+import type { Hex } from 'viem';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  TRANSACTION_TYPE_CALLS,
+  TRANSACTION_TYPE_CONTRACTS,
+} from '../constants';
+import { useSendSCWTransactions } from './useSendSCWTransactions';
+
+describe('useSendSCWTransactions', () => {
+  it('should call writeContractsAsync when transactionType is TRANSACTION_TYPE_CONTRACTS', async () => {
+    const writeContractsAsync = vi.fn().mockResolvedValue(undefined);
+    const sendCallsAsync = vi.fn();
+    const contracts = [
+      { address: '0x789' as Hex, abi: [], functionName: 'test' },
+    ];
+    const capabilities = {};
+
+    const { result } = renderHook(() =>
+      useSendSCWTransactions({
+        transactionType: TRANSACTION_TYPE_CONTRACTS,
+        contracts,
+        capabilities,
+        writeContractsAsync,
+        sendCallsAsync,
+      }),
+    );
+
+    await result.current();
+
+    expect(writeContractsAsync).toHaveBeenCalledWith({
+      contracts,
+      capabilities,
+    });
+    expect(sendCallsAsync).not.toHaveBeenCalled();
+  });
+
+  it('should call sendCallsAsync when transactionType is TRANSACTION_TYPE_CALLS', async () => {
+    const writeContractsAsync = vi.fn();
+    const sendCallsAsync = vi.fn().mockResolvedValue(undefined);
+    const calls = [{ to: '0x123' as Hex, data: '0x456' as Hex }];
+    const capabilities = {
+      /* mock capabilities */
+    };
+
+    const { result } = renderHook(() =>
+      useSendSCWTransactions({
+        transactionType: TRANSACTION_TYPE_CALLS,
+        calls,
+        capabilities,
+        writeContractsAsync,
+        sendCallsAsync,
+      }),
+    );
+
+    await result.current();
+
+    expect(sendCallsAsync).toHaveBeenCalledWith({
+      calls,
+      capabilities,
+    });
+    expect(writeContractsAsync).not.toHaveBeenCalled();
+  });
+
+  it('should not call either function when transactionType is unknown', async () => {
+    const writeContractsAsync = vi.fn();
+    const sendCallsAsync = vi.fn();
+
+    const { result } = renderHook(() =>
+      useSendSCWTransactions({
+        transactionType: 'UNKNOWN_TYPE',
+        writeContractsAsync,
+        sendCallsAsync,
+      }),
+    );
+
+    await result.current();
+
+    expect(writeContractsAsync).not.toHaveBeenCalled();
+    expect(sendCallsAsync).not.toHaveBeenCalled();
+  });
+
+  it('should not call writeContractsAsync when contracts are not provided', async () => {
+    const writeContractsAsync = vi.fn();
+    const sendCallsAsync = vi.fn();
+
+    const { result } = renderHook(() =>
+      useSendSCWTransactions({
+        transactionType: TRANSACTION_TYPE_CONTRACTS,
+        writeContractsAsync,
+        sendCallsAsync,
+      }),
+    );
+
+    await result.current();
+
+    expect(writeContractsAsync).not.toHaveBeenCalled();
+    expect(sendCallsAsync).not.toHaveBeenCalled();
+  });
+
+  it('should not call sendCallsAsync when calls are not provided', async () => {
+    const writeContractsAsync = vi.fn();
+    const sendCallsAsync = vi.fn();
+
+    const { result } = renderHook(() =>
+      useSendSCWTransactions({
+        transactionType: TRANSACTION_TYPE_CALLS,
+        writeContractsAsync,
+        sendCallsAsync,
+      }),
+    );
+
+    await result.current();
+
+    expect(writeContractsAsync).not.toHaveBeenCalled();
+    expect(sendCallsAsync).not.toHaveBeenCalled();
+  });
+});

src/transaction/hooks/useSendSCWTransactions.tsx

@@ -0,0 +1,47 @@
+import { useCallback } from 'react';
+import type { ContractFunctionParameters } from 'viem';
+import {
+  TRANSACTION_TYPE_CALLS,
+  TRANSACTION_TYPE_CONTRACTS,
+} from '../constants';
+import type { CallsType, WalletCapabilities } from '../types';
+
+export const useSendSCWTransactions = ({
+  transactionType,
+  contracts,
+  calls,
+  capabilities,
+  writeContractsAsync,
+  sendCallsAsync,
+}: {
+  transactionType: string;
+  contracts?: ContractFunctionParameters[];
+  calls?: CallsType[];
+  capabilities?: WalletCapabilities;
+  // biome-ignore lint: cannot find module 'wagmi/experimental/query'
+  writeContractsAsync: any;
+  // biome-ignore lint: cannot find module 'wagmi/experimental/query'
+  sendCallsAsync: any;
+}) => {
+  return useCallback(async () => {
+    if (transactionType === TRANSACTION_TYPE_CONTRACTS && contracts) {
+      await writeContractsAsync({
+        contracts,
+        capabilities,
+      });
+    }
+    if (transactionType === TRANSACTION_TYPE_CALLS && calls) {
+      await sendCallsAsync({
+        calls,
+        capabilities,
+      });
+    }
+  }, [
+    writeContractsAsync,
+    sendCallsAsync,
+    calls,
+    contracts,
+    capabilities,
+    transactionType,
+  ]);
+};