Contract 0xb6A5D547d0A325Ffa0357E2698eB76E165b606BA

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.9;

import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

/// @title disCarbon Devcon 6 attendee pooling contract
/// @author haurog, danceratopz
/// @notice This contract exchanges the coins/tokens of the users for carbon
///         tokens (NCT) and sends them to the pooling address. This contract
///         never owns any coins or tokens as all transactions happen instantly
///         and are forwarded in the same transaction.

contract Devcon_Offset_Pool {
    using SafeERC20 for IERC20;

    /// @notice Stores all contributions (summed up) for each address
    mapping(address => uint256) public contributions;
    /// @notice An array of addresses which have contributed
    address[] public contributorsAddresses;
    /// @notice Sum of all contributions
    uint256 public totalCarbonPooled = 0;
    /// @notice Address to where all the contributions are sent to (to be offset manually later)
    address public poolingAddress = 0x439d22a39cD2d0f0572ed05D3c5081d6117B8031; // Devcon VI multisig

    address private sushiRouterAddress =
        0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506;
    address private NCTAddress = 0xD838290e877E0188a4A44700463419ED96c16107;
    address private WMATICAddress = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270;
    address private USDCAddress = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;

    ///@notice Emitted after carbon tokens have been sent to pooling address.
    event ContributionSent(string tokenOrCoin, uint256 carbonTokenContributed);

    ///@dev Needed, otherwise uniswap router for matic fails
    receive() external payable {}

    ///@dev Needed, otherwise uniswap router for matic fails
    fallback() external payable {}

    /// @notice Receives Matic, swaps to carbon token and forwards the swapped
    ///         tokens. Returns any excess Matic.
    /// @param carbonAmount The number of carbon tokens that need to be forwarded.
    function participateWithMatic(uint256 carbonAmount) public payable {
        swapMaticToCarbonToken(carbonAmount);
        doAccounting(carbonAmount);
        forwardCarbonTokenToPool(carbonAmount);
        returnExcessMatic();
        emit ContributionSent("Matic", carbonAmount);
    }

    /// @notice Takes user approved token, swaps to carbon token and forwards
    ///         the swapped tokens. Only takes as many tokens as needed.
    /// @param fromToken Address of the token that should be used to participate.
    /// @param carbonAmount The number of carbon tokens that need to be forwarded.
    function participateWithToken(address fromToken, uint256 carbonAmount)
        public
    {
        if (fromToken == NCTAddress) {
            // Directly transfer NCT tokens.
            IERC20(fromToken).safeTransferFrom(
                msg.sender,
                address(this),
                carbonAmount
            );
        } else {
            // for all other tokens do a swap.
            swapTokenToCarbonToken(fromToken, carbonAmount);
        }

        doAccounting(carbonAmount);
        forwardCarbonTokenToPool(carbonAmount);
        emit ContributionSent("Token", carbonAmount);
    }

    ///@notice returns the needed amount of coins/tokens.
    ///         the swapped tokens. Only takes as many tokens as needed.
    /// @param fromToken Address of the token that should be used to participate.
    ///        To estimate Matic tokens, use WMATIC address.
    /// @param carbonAmount Carbon Amount that needs to be purchased.
    /// @return tokenAmountNeeded How many tokens/coins needed for buying the needed
    ///         carbon tokens.
    function calculateNeededAmount(address fromToken, uint256 carbonAmount)
        public
        view
        returns (uint256)
    {
        // if NCT is supplied no swap necessary
        if (fromToken == NCTAddress) {
            return carbonAmount;
        }

        address[] memory path = makePath(fromToken);

        IUniswapV2Router02 sushiRouter = IUniswapV2Router02(sushiRouterAddress);

        uint256[] memory tokenAmountNeeded = sushiRouter.getAmountsIn(
            carbonAmount,
            path
        );

        return tokenAmountNeeded[0];
    }

    /// @notice A getter function for the array with all the contributors addresses.
    /// @return contributorsAddresses An array (can be empty) with all addresses which contributed.
    function getContributorsAddresses() public view returns (address[] memory) {
        return contributorsAddresses;
    }

    /// @notice A function to get the number of contributors.
    /// @return uint256 A number which is the length of the contributorsAddresses array.
    function getContributorsCount() public view returns (uint256) {
        return contributorsAddresses.length;
    }

    /// @notice This function creates a path from the initial token to the final
    ///         token. It always routes the swaps through USDC (Token > USDC > NCT).
    ///         So make sure there is actually liquidity on sushiswap for your token
    ///         for this path.
    /// @param fromToken Address of the token that should be used to participate.
    ///        To estimate Matic tokens, use WMATIC address.
    /// @return path An array with the path for the sushiswap router to do the swap.
    function makePath(address fromToken)
        private
        view
        returns (address[] memory)
    {
        if (fromToken == USDCAddress) {
            address[] memory path = new address[](2);
            path[0] = USDCAddress;
            path[1] = NCTAddress;
            return path;
        } else {
            address[] memory path = new address[](3);
            path[0] = fromToken;
            path[1] = USDCAddress;
            path[2] = NCTAddress;
            return path;
        }
    }

    /// @notice Does the swap for Matic coins.
    function swapMaticToCarbonToken(uint256 carbonAmount) private {
        IUniswapV2Router02 sushiRouter = IUniswapV2Router02(sushiRouterAddress);
        address[] memory path = makePath(WMATICAddress);

        uint256[] memory tokenToSwap = sushiRouter.getAmountsIn(
            carbonAmount,
            path
        );
        require(
            msg.value >= tokenToSwap[0],
            "Not enough Matic to swap to required carbon Token"
        );

        sushiRouter.swapETHForExactTokens{value: msg.value}(
            carbonAmount,
            path,
            address(this),
            block.timestamp
        );
    }

    /// @notice Does the swap for all ERC-20 tokens.
    /// @param fromToken Address of the token one wants to swap to carbon tokens.
    /// @param carbonAmount Amount of carbon tokens one needs.
    function swapTokenToCarbonToken(address fromToken, uint256 carbonAmount)
        private
    {
        IUniswapV2Router02 routerSushi = IUniswapV2Router02(sushiRouterAddress);
        address[] memory path = makePath(fromToken);
        uint256[] memory tokensNeeded = routerSushi.getAmountsIn(
            carbonAmount,
            path
        );
        // transfer tokens to this contract
        IERC20(fromToken).safeTransferFrom(
            msg.sender,
            address(this),
            tokensNeeded[0]
        );
        // approve tokens for sushiRouter
        IERC20(fromToken).approve(sushiRouterAddress, tokensNeeded[0]);
        // swap
        routerSushi.swapTokensForExactTokens(
            carbonAmount,
            tokensNeeded[0],
            path,
            address(this),
            block.timestamp
        );
    }

    /// @notice Does the accounting (storing addresses and values contributed).
    /// @param carbonAmount Amount of carbon tokens contributed.
    function doAccounting(uint256 carbonAmount) private {
        totalCarbonPooled += carbonAmount;
        if (contributions[msg.sender] == 0) {
            contributorsAddresses.push(msg.sender);
        }
        contributions[msg.sender] += carbonAmount;
    }

    /// @notice Returns excess matic not used in the swap.
    function returnExcessMatic() private {
        (bool success, ) = msg.sender.call{value: address(this).balance}("");
        require(success, "refund failed");
    }

    /// @notice Forwards the carbon tokens to the pooling Address.
    function forwardCarbonTokenToPool(uint256 carbonAmount) private {
        IERC20(NCTAddress).transfer(poolingAddress, carbonAmount);
    }
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"tokenOrCoin","type":"string"},{"indexed":false,"internalType":"uint256","name":"carbonTokenContributed","type":"uint256"}],"name":"ContributionSent","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"uint256","name":"carbonAmount","type":"uint256"}],"name":"calculateNeededAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"contributions","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"contributorsAddresses","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getContributorsAddresses","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getContributorsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"carbonAmount","type":"uint256"}],"name":"participateWithMatic","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"fromToken","type":"address"},{"internalType":"uint256","name":"carbonAmount","type":"uint256"}],"name":"participateWithToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"poolingAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalCarbonPooled","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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