Send Transactions with EIP-7702

import { useState, useCallback } from "react";
import type { KernelAccountClient } from "@zerodev/sdk";
import type { Address, Hash, Hex } from "viem";

interface TransactionCall {
  to: Address;
  data?: Hex;
  value?: bigint;
}

export function useSendTransaction(client: KernelAccountClient | null) {
  const [isPending, setIsPending] = useState(false);
  const [txHash, setTxHash] = useState<Hash | null>(null);
  const [error, setError] = useState<Error | null>(null);

  const sendTransaction = useCallback(
    async (calls: TransactionCall | TransactionCall[]): Promise<Hash> => {
      if (!client) throw new Error("Client not initialized");

      setIsPending(true);
      setError(null);

      try {
        const callsArray = Array.isArray(calls) ? calls : [calls];

        const hash = await client.sendTransaction({
          calls: callsArray.map((call) => ({
            to: call.to,
            data: call.data ?? "0x",
            value: call.value ?? BigInt(0),
          })),
        });

        setTxHash(hash);
        return hash;
      } catch (err) {
        const error = err instanceof Error ? err : new Error("Failed to send");
        setError(error);
        throw error;
      } finally {
        setIsPending(false);
      }
    },
    [client]
  );

  return { sendTransaction, isPending, txHash, error };
}

import { useState, useCallback } from "react";
import type { GelatoSmartWalletClient } from "@gelatonetwork/smartwallet";
import type { Address, Hash, Hex } from "viem";

interface TransactionCall {
  to: Address;
  data?: Hex;
  value?: bigint;
}

export function useSendTransaction(client: GelatoSmartWalletClient | null) {
  const [isPending, setIsPending] = useState(false);
  const [txHash, setTxHash] = useState<Hash | null>(null);
  const [error, setError] = useState<Error | null>(null);

  const sendTransaction = useCallback(
    async (call: TransactionCall): Promise<Hash> => {
      if (!client) throw new Error("Client not initialized");

      setIsPending(true);
      setError(null);

      try {
        const hash = await client.sendTransaction({
          to: call.to,
          value: call.value ?? BigInt(0),
          data: call.data ?? "0x",
        });

        const receipt = await client.waitForTransactionReceipt({ hash });
        setTxHash(receipt.transactionHash);
        return receipt.transactionHash;
      } catch (err) {
        const error = err instanceof Error ? err : new Error("Failed to send");
        setError(error);
        throw error;
      } finally {
        setIsPending(false);
      }
    },
    [client]
  );

  return { sendTransaction, isPending, txHash, error };
}

import { useState, useCallback, useMemo } from "react";
import { Chains } from "porto";
import { RelayActions } from "porto/viem";
import { createClient, http, type Address, type Hash, type Hex, parseEther } from "viem";

interface TransactionCall {
  to: Address;
  data?: Hex;
  value?: bigint;
}

export function useSendTransaction(portoAccount: any) {
  const [isPending, setIsPending] = useState(false);
  const [txHash, setTxHash] = useState<Hash | null>(null);
  const [error, setError] = useState<Error | null>(null);

  const portoClient = useMemo(
    () =>
      createClient({
        chain: Chains.baseSepolia,
        transport: http("https://rpc.porto.sh"),
      }),
    []
  );

  const sendTransaction = useCallback(
    async (call: TransactionCall): Promise<Hash> => {
      if (!portoAccount) throw new Error("Porto account not initialized");

      setIsPending(true);
      setError(null);

      try {
        const receipt = await RelayActions.sendCalls(portoClient, {
          account: portoAccount,
          calls: [
            {
              to: call.to,
              value: call.value ?? BigInt(0),
              data: call.data ?? "0x",
            },
          ],
        });

        setTxHash(receipt.id as Hash);
        return receipt.id as Hash;
      } catch (err) {
        const error = err instanceof Error ? err : new Error("Failed to send");
        setError(error);
        throw error;
      } finally {
        setIsPending(false);
      }
    },
    [portoAccount, portoClient]
  );

  return { sendTransaction, isPending, txHash, error };
}