How to execute the contract with different providers when already connected to a provider

[dumbled00r]

I'm trying to make a dapp, where users can send swap tx on one chain, and on the other chain, the user have to call the receiveMessage to proceed the swap

In my dapp, I specify signers of the same wallet for 2 different chains (I use hook from wagmi): Reference link

and modify it so it will have 2 providers corresponding to only 1 address

Here is my code

const signer = useEthersSigner({
    chainId: chainId,
    rpcUrl: ChainToRPC[ChainIdToName[chainId]],
  });
  const signer2 = useEthersSigner({
    chainId:
      ChainToId[
        ChainIdToName[chainId] === Chain.AVALANCHE
          ? Chain.ETHEREUM
          : Chain.AVALANCHE
      ],
    rpcUrl:
      ChainToRPC[ChainIdToName[chainId]] === Chain.AVALANCHE
        ? ChainToRPC[Chain.ETHEREUM]
        : ChainToRPC[Chain.AVALANCHE],
  });

From there, I want to execute this function with both signers

import { ethers } from "ethers";
import { MESSAGE_TRANSMITTER } from "../../constants/addresses";
import { Chain } from "../../constants/chains";
import fetch from "cross-fetch";
import dotenv from "dotenv";
dotenv.config();
const privateKey = process.env.PRIVATE_KEY || "";

export const RPC = {
  [Chain.AVALANCHE]: "https://api.avax-test.network/ext/bc/C/rpc",
  [Chain.ETHEREUM]: "https://rpc-sepolia.rockx.com",
};

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

const getMessageSentEvent = (
  contract: ethers.Contract,
  txReceipt: ethers.TransactionReceipt
) => {
  const eventLogs = txReceipt.logs;
  const messageSentEventId = ethers.id("MessageSent(bytes)");
  for (const log of eventLogs) {
    if (log.topics[0] === messageSentEventId) {
      return contract.interface.parseLog(log);
    }
  }
  return null;
};

async function fetchAttestation(messageHash: string, maxAttempt = 1000) {
  let attempt = 0;
  while (attempt < maxAttempt) {
    const _response = await fetch(
      `https://iris-api-sandbox.circle.com/attestations/${messageHash}`
    ).then((resp) => resp.json());

    if (_response?.status === "complete") {
      return _response?.attestation;
    }

    await sleep(5000);
    attempt++;
  }
}

export const relayUSDC = async (
  txhash: string,
  chain: Chain,
  signer: ethers.JsonRpcSigner,
  signer2: ethers.JsonRpcSigner
) => {
  // Step 1: Observe for the MessageSent event
  const srcContract = new ethers.Contract(
    MESSAGE_TRANSMITTER[chain],
    ["event MessageSent(bytes message)"],
    signer
  );

  const messageSentReceipt = await signer?.provider?.getTransactionReceipt(
    txhash
  );
  if (!messageSentReceipt) return;

  const log = getMessageSentEvent(srcContract, messageSentReceipt);

  if (log) {
    const message = log.args.message;
    // Step 2: Call the Attestation API to get the signature
    console.log("Receive MessageSent event: ", message);
    const messageHash = ethers.solidityPackedKeccak256(["bytes"], [message]);

    console.log("Getting signature from attestation API...");
    let signature = await fetchAttestation(messageHash);

    if (signature) {
      console.log("Received signature:", signature);
      const destChain =
        chain === Chain.AVALANCHE ? Chain.ETHEREUM : Chain.AVALANCHE;

      const destProvider = new ethers.JsonRpcProvider(RPC[destChain]);

      const destContract = new ethers.Contract(
        MESSAGE_TRANSMITTER[destChain],
        [
          "function receiveMessage(bytes memory _message, bytes calldata _attestation)",
        ],
        signer2
      );

      // Step 3: Send a mint transaction
      console.log("Sending tx to mint USDC on", destChain, "...");
      const receipt = await destContract
        .receiveMessage(message, signature)
        .then((tx: any) => tx.wait());

      console.log("Minted USDC", receipt.hash);
    }
  }
};

However, this part never works

      const receipt = await destContract
        .receiveMessage(message, signature)
        .then((tx: any) => tx.wait());

It outputs the error

SwapSector.tsx:190 Failed to relay USDC: Error: could not coalesce error (error={ "code": -32601, "message": "the method eth_sendTransaction is not available" }, payload={ "id": 4, "jsonrpc": "2.0", "method": "eth_sendTransaction", "params": [ { "data": "0x57ecfd280000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000f8000000000000000100000000000000000004a293000000000000000000000000eb08f243e5d3fcff26a9e38ae5520a669f4019d00000000000000000000000009f3b8679c73c2fef8b59b4f3444d4e156fb70aa50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005425890298aed601595a70ab815c96711a31bc6500000000000000000000000097ec4e4beb78b15a170660056ef9d3d1998f0476000000000000000000000000000000000000000000000000000000000000ead4000000000000000000000000e59d41ebe7b0a5a684b1d6183e4c79163588af0200000000000000000000000000000000000000000000000000000000000000000000000000000082d2c1f7085cc0e47cbb554f0ed732a7c10e9eaf450636c5f914622e5172d95aff15f815b27f9da8ecad6a2db7df56a69d917817bcf6e9775f092d5e3fd56be7e51cb6595150aa35f79557f61d923ac6d4e185830e8ebb405fa7ccb7917119f256851447186015cdf2a1861b7c49279141ebcc5080cb728e2e0b97137d49ad1907dd1b000000000000000000000000000000000000000000000000000000000000", "from": "0x97d4c420a869f1e1591a0d6b2d2354232c805baa", "gas": "0x676b", "to": "0x7865fafc2db2093669d92c0f33aeef291086befd" } ] }, code=UNKNOWN_ERROR, version=6.12.1)

What is the problem, how can I execute the mint function (it worked normally if I initiate a new Wallet with the private key, connected to the destination provider.
But I don't want to have the private key here.