I have an array of struct Campaign. The function launch adds a new Campaign to the array. After that when a user sends some ETH using the pledge function, the transaction succeeds and the eth gets sent but the struct doesn't get updated. I'm using alchemy and ethers

**Solidity**

```
pragma solidity 0.8.10;

import "./ERC20.sol";
import "hardhat/console.sol";

contract Crowdfund is ERC20 {

    event Launch(
        uint id,
        address indexed creator,
        uint goal,
        uint32 startAt,
        uint32 endAt
    );

    event Cancel(uint id);
    event Pledge(uint indexed id, address indexed caller, uint amount);
    event Unpledge(uint indexed id, address indexed caller, uint amount);
    event Claim(uint id);
    event Refund(uint indexed id, address indexed caller, uint amount);
    event Log(uint amount, uint gas);

    struct Campaign {
        address creator;
        uint numberOfInvestors;
        uint goal;
        uint pledged;
        uint32 startAt;
        uint32 endAt;
        bool claimed;
    }

    IERC20 public immutable token;
    address public immutable tokenAddress;
    uint public count;
    mapping(uint => Campaign) public campaigns;
    mapping(uint => mapping(address => uint)) public pledgedAmount;

    constructor(address _token) {
        token = IERC20(_token);
        tokenAddress = _token;
    }

    receive() external payable {
        emit Log(msg.value, gasleft());
    }

    function launch(
        uint _goal,
        uint32 _startAt,
        uint32 _endAt
    ) external returns (uint) {
        require(_startAt >= block.timestamp, "Start at < now");
        require(_endAt >= _startAt, "end at < start at");
        require(_endAt <= block.timestamp + 90 days, "end at > max duration");
        count += 1;
        Campaign storage c = campaigns[count];
        c.creator = msg.sender;
        c.numberOfInvestors = 0;
        c.goal = _goal;
        c.pledged = 0;
        c.startAt = _startAt;
        c.endAt = _endAt;
        c.claimed = false;
        emit Launch(count, msg.sender, _goal, _startAt, _endAt);
        return count;
    }

    function cancel(uint _id) external {
        Campaign memory campaign = campaigns[_id];
        require(msg.sender == campaign.creator, "Not creator");
        require(block.timestamp < campaign.startAt, "started");
        delete campaigns[_id];
        emit Cancel(_id);
    }

    function pledge(uint _id, uint _amount) external payable {
        Campaign storage campaign = campaigns[_id];
        require(_amount > 0, "Amount should be bigger than 0");

        if (pledgedAmount[_id][msg.sender] == 0) {
            campaign.numberOfInvestors += 1;
        }

        (bool success, ) = address(this).call{value: _amount}("");
        require(success, "Call failed");

        campaign.pledged += _amount;
        pledgedAmount[_id][msg.sender] += _amount;
        //token.transferFrom(msg.sender, address(this), _amount);

        emit Pledge(_id, msg.sender, _amount);
    }

    function unpledge(uint _id, uint _amount) external {
        Campaign storage campaign = campaigns[_id];
        require(block.timestamp <= campaign.endAt, "Ended");

        (bool success, ) = msg.sender.call{value: _amount}("");
        require(success, "Call failed");

        campaign.pledged -= _amount;
        pledgedAmount[_id][msg.sender] -= _amount;
        //token.transfer(msg.sender, _amount);

        emit Unpledge(_id, msg.sender, _amount);
    }

    function claim(uint _id) external payable {
        Campaign storage campaign = campaigns[_id];
        require(msg.sender == campaign.creator, "Not creator");
        require(block.timestamp > campaign.endAt, "Not ended");
        require(campaign.pledged >= campaign.goal, "pledge < goal");
        require(!campaign.claimed, "Claimed");

        (bool success, ) = msg.sender.call{value: campaign.pledged}("");     
        require(success, "Call failed");
        campaign.claimed = true;
        //token.transferFrom(msg.sender, campaign.pledged);

        emit Claim(_id);
    }

    function claimShares(uint _id) external {
        require(pledgedAmount[_id][msg.sender] > 0, "Nothing pledged");
        //uint amountDue = pledgedAmount[_id][msg.sender] * 100 / campaigns[_id].goal;
        token.sendToAddress(address(this), msg.sender, pledgedAmount[_id][msg.sender] / 10**16);
    }

    function getTokens(uint amount) external payable {
        token.sendToContract(address(this), amount);
    }

    function refund(uint _id) external {
        Campaign storage campaign = campaigns[_id];
        require(block.timestamp > campaign.endAt, "Not ended");
        require(campaign.pledged < campaign.goal, "pledged < goal");

        uint bal = pledgedAmount[_id][msg.sender];
        (bool success, ) = msg.sender.call{value: bal}("");
        require(success, "Call failed");

        pledgedAmount[_id][msg.sender] = 0;
        //token.transfer(msg.sender, bal);

        emit Refund(_id, msg.sender, bal);
    }

}

```

**Javascript**

```
import env from "react-dotenv";
import {BigNumber, ethers} from 'ethers';
import axios from "axios";
const alchemyKey = process.env.REACT_APP_ALCHEMY_KEY;
const { createAlchemyWeb3 } = require("@alch/alchemy-web3");
const web3 = createAlchemyWeb3(alchemyKey);
const contract_abi = require("./crowdfund-abi.json");
const {CROWDFUND_ADDRESS, ETHERSCAN_KEY} = env;

console.log(CROWDFUND_ADDRESS);
export const CrowdfundContract = new web3.eth.Contract(
  contract_abi,
  CROWDFUND_ADDRESS
);

export const getCampaignsCount = async () => {
  const count = await CrowdfundContract.methods.count().call();
  return count;
}

export const connectWallet = async () => {
   if (window.ethereum) {
      try {
        const addressArray = await window.ethereum.request({
          method: "eth_requestAccounts",
        });
        return addressArray

      } catch (err) {
        return err
      }
    }
};

export const pledgedAmount = async (id, address) => {
  const res = await CrowdfundContract.methods.pledgedAmount(id, address).call();
  return res
}

export const pledgeAmount = async (id, amount, address) => {
  const total = amount / (10 ** 18);
  const value = total.toString();
 const transactionParameters = {
    to: CROWDFUND_ADDRESS,
    from: address,
    data: CrowdfundContract.methods.pledge(id, amount).encodeABI({from: address}),
    value: ethers.utils.parseEther(value).toHexString()
  }

  try {
    const txHash = await window.ethereum.request({
      method: "eth_sendTransaction",
      params: [transactionParameters]
    })

    const interval = setInterval(function() {
      console.log("Attempting to get transaction receipt...");
      web3.eth.getTransactionReceipt(txHash, async function(err, rec) {
        if (rec) {
          console.log(rec);
          clearInterval(interval);
        }
        if (err) {
          console(err);
          clearInterval(interval);
        }
      });
    }, 1000) 

  } catch (err) {
    console.log(err.message);
  }
}

export const addCampaign = async (goal, startAt, endAt, address, campaign) => {
  const transactionParameters = {
    to: CROWDFUND_ADDRESS,
    from: address,
    data: CrowdfundContract.methods.launch(goal, startAt, endAt).encodeABI()
  }

 try {
    const txHash = await window.ethereum.request({
       method: "eth_sendTransaction",
       params: [transactionParameters]
    });
    const interval = setInterval(function() {
      console.log("Attempting to get transaction receipt...");
      web3.eth.getTransactionReceipt(txHash, async function(err, rec) {
        if (rec) {
          console.log(rec);
          await axios.post("http://localhost:8080/addCampaign", campaign)
          .then((res) => {
            console.log(res.response);
          })
          .catch((error) => {
            console.log(error);
          });
          clearInterval(interval);
        }
      });
    }, 1000)    
 } catch (err) {
    console.log(err.message)
 }
}

export const getCampaignDetails = async (id) => 
{
  const res = await CrowdfundContract.methods.campaigns(id).call();
  return res;
}

```

The pledge function is supposed to update the pledged property and the numberOfInvestors property.

Am I calling the function incorrectly using ethers or is it a solidity issue?