Неожиданная ошибка не удалось оценить газ для подтверждения

PancakeSwap – популярная децентрализованная биржа. Одним из основных преимуществ является то, что это более дешевая альтернатива платформам на основе Ethereum. Поскольку на бирже ежедневно происходят миллионы транзакций, вполне понятно, если время от времени случаются сбои. “не может оценить плату за газ” ошибка — одна из наиболее распространенных проблем, с которыми сталкиваются пользователи PancakeSwap. Это может быть вызвано несколькими факторами и часто означает, что ваша транзакция не будет обработана. В этой статье мы рассмотрим, что вызывает эту ошибку и как ее можно исправить.

Время от времени вы можете столкнуться с проблемами при попытке поменять токены на PancakeSwap. Например, вы можете столкнуться с сообщением “невозможно оценить плату за газ” ошибка. Не беспокоиться. Есть несколько вещей, которые вы можете сделать, чтобы решить эту проблему. Давайте рассмотрим их здесь.

Проблема: низкая устойчивость к проскальзыванию

Проскальзывание – это разница между ожидаемой и фактической ценой сделки. Это торговый фактор, но проскальзывание происходит чаще с криптовалютой. Это в основном связано с тем, что сами токены нестабильны по цене и более подвержены проблемам с ликвидностью. Низкий допустимый уровень проскальзывания может помешать выполнению вашей транзакции, в результате чего “невозможно оценить комиссию за газ” сообщение.

Решение. Увеличьте допуск на проскальзывание

Увеличение допуска на проскальзывание вашей транзакции может решить проблему. Однако вы должны иметь в виду, что вы можете не получить оптимальную цену за свой токен. Вот как можно изменить допуск на проскальзывание.

1. Перейдите на страницу PancakeSwap и выберите токены, которые вы хотите обменять, поместив их в поле “Кому” и “От” полей.
   
2. Нажмите значок “Настройки” и найдите “Slippage Допуск” раздел.
   
3. Введите “12” в слот и выйдите из настроек.
   

Допуск проскальзывания теперь скорректирован и ваша транзакция должна пройти.

Допуск проскальзывания 12% часто используется, потому что это кажется оптимальным. Он достаточно высок, чтобы сделки были успешными, но достаточно низок, чтобы получить хорошую цену за ваши токены.

Проблема: слишком много знаков после запятой

Если количество токенов содержит слишком много знаков после запятой, у PancakeSwap могут возникнуть проблемы с выполнением транзакции. Например, если стоимость вашей монеты составляет 651,83496372, вы, скорее всего, получите сообщение “невозможно оценить комиссию за газ” alert.

Решение. Уменьшите количество десятичных цифр

Чтобы транзакция прошла, вам придется уменьшить количество используемых десятичных цифр. Узнайте, как это сделать.

1. Запустите PancakeSwap и перейдите в раздел Swap.
   
2. Введите токен, который хотите приобрести, в поле “Кому” столбец.
   
3. Введите токен, который вы хотите заменить, в “От” столбец.
   
4. Измените последние цифры токена в столбце “ От” столбец на нули.
   

Теперь это должно решить проблему, и ваша транзакция может быть выполнена.

< p> Вам нужно будет изменить количество токенов в “From” столбец, потому что тот, что находится в столбце “Кому” столбец не может быть аппроксимирован. Вы не можете оценить “Кому” поле, если вы покупаете токен.

Проблема: слишком много нулей

У PancakeSwap, похоже, есть проблемы с расчетом транзакций, когда суммы токенов имеют слишком много нулей. Например, если вы пытаетесь обменять монеты стоимостью 200 000, вы можете получить сообщение “невозможно оценить комиссию за газ” сообщение.

Решение. Измените последние цифры с нуля

Если ваша транзакция не проходит из-за слишком большого количества нулей в вашей монете, попробуйте изменить последние цифры, как описано ниже.

1. Запустите PancakeSwap и перейдите в раздел “Обмен”.
   
2. В “Кому” введите токен, который хотите купить.
   
3. Введите токен, который вы хотите обменять в поле “From” slot.
   
4. Измените последние цифры в “From” раздел на числа, отличные от нуля.
   

Теперь проблема должна быть устранена, и транзакция должна быть завершена без появления сообщения об ошибке. .

Проблема: транзакция выполняется слишком медленно

Вы можете получить сообщение “невозможно оценить плату за газ” сообщение об ошибке, потому что скорость транзакции слишком низкая. PancakeSwap построен на основе Binance Smart Chain, и для обработки сделок они должны быть проверены в блокчейне. Если ваш своп настроен на более медленную скорость, он может застрять в конце очереди, пропущенной для более привлекательных сделок. Это связано с тем, что более высокая скорость транзакций повлечет за собой более высокие сетевые сборы.

Решение: увеличьте скорость транзакций

PancakeSwap имеет три различных скорости транзакций. Есть стандартный, быстрый и мгновенный. Более высокая скорость транзакций будет более привлекательной для валидаторов, поскольку у нее более высокие сетевые комиссии. Вот как можно увеличить скорость обмена.

1. Запустите PancakeSwap и коснитесь значка “Настройки”.
   
2. Нажмите “Быстро” или “Мгновенное” чтобы завершить процесс.
   

Теперь ваша транзакция должна быть быстрее, и проблема исправлено.

Докопаться до сути проблемы

PancakeSwap — фантастическая платформа для торговли криптовалютой. Однако биржа не лишена недостатков. Вы можете столкнуться с сообщением “невозможно оценить плату за газ” ошибка, которая помешает вам продолжить сделку. Приведенное выше руководство должно помочь вам определить и устранить проблему, если она возникнет.

Сталкивались ли вы с сообщением “невозможно оценить плату за газ” ошибка на PancakeSwap? Что вы сделали, чтобы решить проблему? Дайте нам знать в разделе комментариев ниже.

Это может быть вызвано обменом токена, например Safemoon, Bonfire или других.

Подобные ошибки очень распространены в PancakeSwap, поэтому не только вы сталкиваетесь с ними.

В этом руководстве вы узнаете, что означает «невозможно оценить газ» на PancakeSwap и как это исправить.

Что означает «gas: transactiob may fail or may require manual gasl limit» на PancakeSwap?

.

«Не может оценить газ» на PancakeSwap означает, что биржа не может оценить комиссию за транзакцию.

Обычно это происходит, когда в количестве токенов слишком много десятичных знаков.

Когда в количестве жетонов слишком много десятичных знаков, может возникнуть ошибка «Невозможно оценить газ».

Например, если вы меняете BNB на 155.968325 ANKR, вы можете получить сообщение об ошибке.

Это связано с тем, что в токене слишком много десятичных знаков.

Еще одна причина, по которой вы получили ошибку «Не могу оценить газ», заключается в том, что токен может быть мошенничеством.

Как на примере с Orlov Analytics с токеном CDX coin

Чтобы проверить, является ли токен мошенничеством, вам необходимо просмотреть его последние транзакции.

сли в последнее время есть люди, покупающие и продающие токен, то, скорее всего, это не афера, а сообщение об ошибке вызвано PancakeSwap.

Сообщение об ошибке можно легко исправить, выполнив следующие действия.

Как исправить «не могу оценить газ» на PancakeSwap

Чтобы исправить ошибку «не могу оценить газ» на PancakeSwap, измените допуск по проскальзыванию на 12%.

Затем вам нужно изменить количество токенов, которые вы пытаетесь обменять.

После того как вы измените количество токенов, которые вы пытаетесь поменять местами, сообщение об ошибке будет исправлено.

Например, если вы пытаетесь поменять BNB на Safemoon, количество Safemoon может содержать много десятичных знаков.

Или последние числа Safemoon могут быть очень рандомизированы (например, 5123859).

Когда это происходит, у PancakeSwap могут возникнуть проблемы с оценкой комиссии за транзакцию.

В результате транзакция не состоится, и вы получите ошибку «Не могу оценить газ».

Кроме того, низкий допуск к проскальзыванию также может привести к сбою вашей транзакции.

Это связано с комиссией токена.

Вы можете смягчить это, постепенно увеличивая допуск по проскальзыванию, чтобы определить минимальный допуск проскальзывания для успешной транзакции

Шаг №1: Измените допуск по проскальзыванию на 12%

Для начала нужно открыть PancakeSwap.

Как только вы перейдете на PancakeSwap, выберите токены, которые вы хотите обменять.

Вы можете сделать это, выбрав токен, который хотите купить, в поле «Кому».

Затем выберите токен, который вы хотите использовать для обмена, в поле «От».

Затем вам нужно изменить допуск по проскальзыванию.

Для этого коснитесь значка «Настройки».

После того, как вы нажмете на значок «Настройки», откроется всплывающее окно «Настройки».

Во всплывающем окне «Настройки» вы увидите поле «Допуск по проскальзыванию».

В поле введите «12» в качестве допуска по проскальзыванию.

Затем закройте всплывающее окно «Настройки», нажав значок «x».

В качестве альтернативы вы можете постепенно увеличивать допуск по проскальзыванию .

Начните с 2% допуска на проскальзывание, затем увеличивайте его до 4%, 6%. 8% и более.

Это позволит вам найти минимальный допуск проскальзывания для успешной транзакции.

Однако, если вы пытаетесь купить токен, такой как Safemoon, вам необходимо установить допуск по проскальзыванию в 12%.

Это связано с комиссией за токен.

Шаг № 2: замените последние цифры на ноль

.Далее нужно поменять последние цифры токена на ноль.

Сначала выберите токен, который вы хотите купить, в поле «Кому».

Затем выберите токен, который вы хотите использовать для обмена (например, BNB, Ethereum).

Затем введите количество BNB или Ethereum, которое вы хотите обменять на токен.

Например, если вы хотите обменять 0,04515 BNB, введите «0,04515» в поле «От».

Это сделает оценочное поле «Кому».

Однако значение поля «Кому» невозможно оценить, если вы покупаете токен.

Если поле «До» оценено, вы можете получить сообщение об ошибке, например, «невозможно оценить газ», когда вы нажмете «Поменять местами».

Вместо этого вам нужно поле «От» для оценки.

Когда вы покупаете токен, вам нужно, чтобы поле «От» оценивалось.

Для этого измените последние числа токена, который вы пытаетесь купить, на ноль.

Например, если вы пытаетесь купить 155,958 ANKR, измените его на 155,000.

В большинстве случаев это устранит ошибку «невозможно оценить газ».

Однако, если все последние числа токена, который вы пытаетесь купить, уже равны нулю, попробуйте изменить его на случайные числа.

Например, если вы пытаетесь купить 155 000 ANKR, измените его на 155 958.

Если вы по-прежнему получаете сообщение об ошибке «Не могу оценить газ», попробуйте изменить числа в полях «Кому» и «От» на случайные, пока транзакция не будет успешной.

Это связано с тем, что сообщение об ошибке обычно вызвано количеством токенов, которые вы пытаетесь поменять местами.

Заключение

Вот несколько общих правил, которым нужно следовать, когда вы покупаете токен для продажи:

Если вы покупаете токен , убедитесь, что поле «От» оценено.

Для этого измените последние цифры токена в поле «Кому».

С другой стороны, если вы продаете токен , убедитесь, что поле «Кому» оценено.

Для этого измените последние цифры токена в поле «От».

Это снизит вероятность возникновения любых ошибок транзакций, таких как ошибка «невозможно оценить газ».

greeting

1- i will start by writing the general configurations(system, version, smart contract overall idea).

2- then i will show the main problem(with small code line, that i think it need edit).

3- third part i will show what i try until now and the results

4- at the end of i will add the github link for my full code.

note: the full original code produced by mr. PatrickAlphaC.

a- general configurations(system, version, smart contract overall idea):

• a1- operation system: opensuse leap 15.3
• a2- hardhat version: 2.8.3
• a3- node version: v14.18.3
• a4- npm version: 8.3.0
• a5- metamask wallet addone to firefox
• a6- target block chain: polygon(main net, test net)
• a7- smart contract overall idea: use svg to create erc-721 nft, where it’s metadata totally stored on chain(the smart contract mint tokenurl to polygon chain).

b- the main problem:

every thing work good as the size of minted file (tokenurl) less than 23.8kb(small than 23.8 kb). where i target mint file that twice this size (every tokenurl equal 50kb). so when try mint tokenurl with size (23.8 Kb < size < 50 Kb) i recive next error message.

An unexpected error occurred:
   Error: ERROR processing /home/naive/demos/secondtry/deploy/01_Deploy_SVGNFT.js:
   Error: cannot estimate gas; transaction may fail or may require manual gas limit (error={"name":"ProviderError","code":-
   32000,"_isProviderError":true}, method="estimateGas", transaction={"from":"metamask wallet address","to":"contract address",

c- what i try until now and the results:

• c1- try set the gas limit in «hardhat.config» but did not make any effect(it was during search so i do not remmber the form or values).

• c2- in «01_Deploy_SVGNFT» add gaslimit to tx, so the code line look like next.

  • c2-0 origonal code line before edit it: tx = await svgNFT.create(svg)
  • c2-1 code line after edit it: tx = await svgNFT.create(svg, {gasLimit: 3000000 })
  • c2-2 the result: give me some error message about wrong syntic (forum, typing)

• c3- in «01_Deploy_SVGNFT» add gaslimit to tx, so the code line look like next.

  • c3-0 origonal code line before edit it: tx = await svgNFT.create(svg)

  • c3-1 code line after edit it: tx = await svgNFT.create({svg}, {gasLimit: 3000000 })

  • c3-2 the results:

    • 3-2-0 contract deploying, svg uploading, contract verifying, the matic value decrease in metamask wallet(gas value transfer succeed) all thing look good.
    • 3-2-1 when go to opensea there’s no image appears.
    • 3-2-2 when go to polygonscan or etherscan and use token id to see the token uri it return nothing (ther’s no metadata string appears, nothing appears).

d- the next github link for full code(contracts, deploy, hardhat.config.js, helper-hardhat-config.js and img folder that contains (preproduced tokenurl)

https://github.com/naive2022/onchainfork

hope help me find how can mint preproduced tokenurl(every file size is 50kb) without face this problem when use polygon test or polygon main network.

thanks in advanced

greeting

1- i will start by writing the general configurations(system, version, smart contract overall idea).

2- then i will show the main problem(with small code line, that i think it need edit).

3- third part i will show what i try until now and the results

4- at the end of i will add the github link for my full code.

note: the full original code produced by mr. PatrickAlphaC.

a- general configurations(system, version, smart contract overall idea):

• a1- operation system: opensuse leap 15.3
• a2- hardhat version: 2.8.3
• a3- node version: v14.18.3
• a4- npm version: 8.3.0
• a5- metamask wallet addone to firefox
• a6- target block chain: polygon(main net, test net)
• a7- smart contract overall idea: use svg to create erc-721 nft, where it’s metadata totally stored on chain(the smart contract mint tokenurl to polygon chain).

b- the main problem:

every thing work good as the size of minted file (tokenurl) less than 23.8kb(small than 23.8 kb). where i target mint file that twice this size (every tokenurl equal 50kb). so when try mint tokenurl with size (23.8 Kb < size < 50 Kb) i recive next error message.

An unexpected error occurred:
   Error: ERROR processing /home/naive/demos/secondtry/deploy/01_Deploy_SVGNFT.js:
   Error: cannot estimate gas; transaction may fail or may require manual gas limit (error={"name":"ProviderError","code":-
   32000,"_isProviderError":true}, method="estimateGas", transaction={"from":"metamask wallet address","to":"contract address",

c- what i try until now and the results:

• c1- try set the gas limit in «hardhat.config» but did not make any effect(it was during search so i do not remmber the form or values).

• c2- in «01_Deploy_SVGNFT» add gaslimit to tx, so the code line look like next.

  • c2-0 origonal code line before edit it: tx = await svgNFT.create(svg)
  • c2-1 code line after edit it: tx = await svgNFT.create(svg, {gasLimit: 3000000 })
  • c2-2 the result: give me some error message about wrong syntic (forum, typing)

• c3- in «01_Deploy_SVGNFT» add gaslimit to tx, so the code line look like next.

  • c3-0 origonal code line before edit it: tx = await svgNFT.create(svg)

  • c3-1 code line after edit it: tx = await svgNFT.create({svg}, {gasLimit: 3000000 })

  • c3-2 the results:

    • 3-2-0 contract deploying, svg uploading, contract verifying, the matic value decrease in metamask wallet(gas value transfer succeed) all thing look good.
    • 3-2-1 when go to opensea there’s no image appears.
    • 3-2-2 when go to polygonscan or etherscan and use token id to see the token uri it return nothing (ther’s no metadata string appears, nothing appears).

d- the next github link for full code(contracts, deploy, hardhat.config.js, helper-hardhat-config.js and img folder that contains (preproduced tokenurl)

https://github.com/naive2022/onchainfork

hope help me find how can mint preproduced tokenurl(every file size is 50kb) without face this problem when use polygon test or polygon main network.

thanks in advanced

function buyLoan(address _sellLoan, address _sellPortfolio) public {

    uint tradePrice = Loan(_sellLoan).getBalance();

    // Now check if funds available
    if (tradePrice > address(this).balance) {
        // Not enough funds, so revert
        revert();
    } else {
        // Enough funds, so execute purchase

        // Get Sell Portfolio for transfer
        Portfolio sp = Portfolio(_sellPortfolio);

        // Finalize sale of Loan
        tr.executeTrade(_sellLoan, _tradeDate);

      if (!address(sp).send(tradePrice))
            revert();

        // Now add loan to buying portfolio
        addLoan(_sellLoan, tradePrice);

        // Delete loan from selling portfolio
        sp.deleteLoan(_sellLoan);
        }

}

1 ответ

У меня есть веб-приложение dapp со смарт-контрактом, развернутое в тестовой сети rinkeby.
На моем веб-сайте dapp у меня есть функция обмена токенов и ставок.
Ссылка: https://doxa-staking.netlify.app
Когда я обмениваю свой эфир на свой токен, он работает нормально. Теперь о функции стейкинга dapp, когда я впервые ставлю токен, он работает нормально, но я не могу поставить еще один во второй раз. Всякий раз, когда я хочу поставить оставшийся токен или просто поставить часть токена, я получаю ошибку не могу оценить газ.

Это ошибки, которые я получаю:

Сбой с ошибкой «Значение меньше минимального ETH».

Предупреждение: при выполнении контракта произошла ошибка — исполнение отменено

Ссылка на ошибку транзакции:
https://rinkeby.etherscan.io/tx/0xa4976881e4762e13e634cad1189d851a9182f3b4d6f1ea6bbfd64ebf2e22424c.

Ссылка на коды смарт-контрактов стейкинга:
https://rinkeby.etherscan.io/address/0xb1fed59cc80145ba05a0c248b55c0631a363f780#code.
Ссылка на код смарт-контракта токена:
https://rinkeby.etherscan.io/address/0xd99b4bb049a6dd490901cdfa33f15c4fac097ef0#code.

Ссылка на исходный код моего dapp reactjs:
https://github.com/isofttechn/staking-dapp/blob/main/src/components/Home/index.js
Я действительно не знаю, возникает ли ошибка из-за смарт-контракта или самого децентрализованного приложения.

Смарт-контракт стейкинга, из которого исходит ошибка

pragma solidity ^0.8.1;


library AddressUpgradeable {
    
    function isContract(address account) internal view returns (bool) {
       
        return account.code.length > 0;
    }

    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");
    }

    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    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");
    }

    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);
    }

    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    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);
    }

    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            if (returndata.length > 0) {
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

pragma solidity ^0.8.0;

abstract contract Initializable {
    bool private _initialized;

    bool private _initializing;
    modifier initializer() {
        require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    function _isConstructor() private view returns (bool) {
        return !AddressUpgradeable.isContract(address(this));
    }
}

pragma solidity ^0.8.0;
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
    uint256[50] private __gap;
}

pragma solidity ^0.8.0;
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }
    function owner() public view virtual returns (address) {
        return _owner;
    }
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
    uint256[49] private __gap;
}

pragma solidity ^0.8.0;
interface IERC20Upgradeable {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    function toString(uint256 value) internal pure returns (string memory) {

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;

            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {

        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {

        return keccak256(abi.encodePacked("x19Ethereum Signed Message:n32", hash));
    }

    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("x19Ethereum Signed Message:n", Strings.toString(s.length), s));
    }

    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("x19x01", domainSeparator, structHash));
    }
}


abstract contract EIP712 {
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}






contract whitelistChecker is EIP712 {

    string private constant SIGNING_DOMAIN = "Azo_Staking";
    string private constant SIGNATURE_VERSION = "1";

     struct Whitelist {
        address userAddress;
        address contractAddress;
        uint256 amount;
        uint256 id;
        uint256 noOfDays ;
        uint256 timestamp;
        bytes signature;
    }
    constructor() EIP712(SIGNING_DOMAIN, SIGNATURE_VERSION){

    }

    function getSigner(Whitelist memory whitelist) public view returns(address){
        return _verify(whitelist);
    }

    /// @notice Returns a hash of the given whitelist, prepared using EIP712 typed data hashing rules.

function _hash(Whitelist memory whitelist) internal view returns (bytes32) {
        return _hashTypedDataV4(keccak256(abi.encode(
                keccak256("Whitelist(address userAddress,address contractAddress,uint256 amount,uint256 id,uint256 noOfDays,uint256 timestamp)"),
                whitelist.userAddress,
                whitelist.contractAddress,
                whitelist.amount,
                whitelist.id,
                whitelist.noOfDays,
                whitelist.timestamp
            )));
    }
    function _verify(Whitelist memory whitelist) internal view returns (address) {
        bytes32 digest = _hash(whitelist);
        return ECDSA.recover(digest, whitelist.signature);
    }

}



contract doxaStake is OwnableUpgradeable,whitelistChecker{

    IERC20Upgradeable public stakeToken;
    IERC20Upgradeable public rewardToken;

    uint256 private _totalSupply;
    address public signer;
    uint256 public givenRewards;

    uint256 public totalRewardFunds;
    uint256 public rewardBalance = totalRewardFunds;

    uint day = 60;
    uint accuracyFactor = 10 ** 10;

    mapping(address => uint256) public totalStakeRecords;
    mapping(address => mapping (uint => bool)) private usedNonce;
    mapping(address => stakerDetails[]) public Stakers;
    mapping(address=>bool) public isBlocklisted;
       modifier isblocklist(address _addr){
        require(!isBlocklisted[_addr],"wallet is blocklisted");
        _;
    }

      struct stakerDetails {
        uint id;
        uint balance;
        uint totalRewards;
        uint lockingPeriod;
        uint lastUpdatedTime;
        uint maxTime;
        uint rewardEarned;
        uint rewardPaidOut;
        uint apr;
    }

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount, uint256 noOfDays);
    event Unstaked(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
    event RecoverToken(address indexed token, uint256 indexed amount);
    modifier updateReward(address account, uint id) {
        Stakers[account][id].rewardEarned = earned(account, id);
        _;
    }

    function getRewardRate(address account, uint id) public view returns (uint256) {
        uint daysInTimestamp = Stakers[account][id].lockingPeriod * day;

        uint amount = getAmountWithApr(account, id);

        return (amount*(Stakers[account][id].lockingPeriod))/(daysInTimestamp*(365));
    }

    function getAmountWithApr(address account, uint id) internal view returns(uint) {
        return ((Stakers[account][id].balance) * (Stakers[account][id].apr))/(100 *accuracyFactor);
    }

    function earned(address account, uint id) public view returns (uint256) {
        if (Stakers[account][id].rewardPaidOut < Stakers[account][id].totalRewards) {
            if (block.timestamp >= Stakers[account][id].maxTime) {
              return (Stakers[account][id].totalRewards)-(Stakers[account][id].rewardPaidOut);
            }

            return
               (getRewardRate(account, id)) * ((block.timestamp)-(Stakers[account][id].lastUpdatedTime));
        } else {
            return 0;
        } 
    }

    function isRewardAvailable(uint rewardAmount) public view returns (bool) {
        if (rewardBalance >= rewardAmount) {
            return true;
        }
        return false;
    }

    function getAPR(uint noOfDays) public view returns(uint) {
         require(noOfDays <=365,"Only 1 year");
      return ((noOfDays * (5 * (noOfDays * accuracyFactor)) /(10000)) + (50 * accuracyFactor));
    }

    function rewardForPeriod(uint amount, uint noOfDays) public view returns (uint) {
         require(noOfDays <=365,"Only 1 year");
        uint apr = getAPR(noOfDays);
        uint reward = (amount *apr)/((100) * (accuracyFactor));
        uint totalRewardForPeriod = (reward/365) *(noOfDays);
        require(isRewardAvailable(totalRewardForPeriod), "Not enought reward available");
        return totalRewardForPeriod;
    }

    function stake(uint256 amount, uint noOfDays,  Whitelist memory stakeo) external isblocklist(msg.sender){
        require(noOfDays <=365,"Only 1 year");
        require(!usedNonce[msg.sender][stakeo.timestamp],"Nonce : Invalid Nonce");
        require (getSigner(stakeo) == signer,'!Signer');
        usedNonce[msg.sender][stakeo.timestamp] = true;
        require(amount > 0, "Cannot stake 0");
        stakerDetails memory staker;

        uint daysInTimestamp = noOfDays * day;

        uint rewardForUser = rewardForPeriod(amount, noOfDays);
        totalStakeRecords[msg.sender] += 1;
        staker.id = totalStakeRecords[msg.sender];
        staker.lockingPeriod = noOfDays;
        staker.totalRewards = rewardForUser;
        staker.lastUpdatedTime = block.timestamp;
        staker.maxTime = block.timestamp + (daysInTimestamp);
        staker.balance = amount;
        staker.apr = getAPR(noOfDays);

        Stakers[msg.sender].push(staker);
        rewardBalance -= rewardForUser;
        _totalSupply +=amount;
        stakeToken.transferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount, noOfDays);
    }

    function unstake(uint id, Whitelist memory stakeo) internal {
        require(!usedNonce[msg.sender][stakeo.timestamp],"Nonce : Invalid Nonce");
        require (getSigner(stakeo) == signer,'!Signer');
        usedNonce[msg.sender][stakeo.timestamp] = true;
        require(block.timestamp >= Stakers[msg.sender][id].maxTime, "Tokens are locked! Try unstaking after locking period");
        uint amount = Stakers[msg.sender][id].balance;
        _totalSupply -=amount;
        Stakers[msg.sender][id].balance = 0;
        stakeToken.transfer(msg.sender, amount);
        emit Unstaked(msg.sender, amount);
    }


    function getReward(uint id,Whitelist memory stakeo) external  updateReward(msg.sender, id) isblocklist(msg.sender){
        require(!usedNonce[msg.sender][stakeo.timestamp],"Nonce : Invalid Nonce");
        require (getSigner(stakeo) == signer,'!Signer');
        usedNonce[msg.sender][stakeo.timestamp] = true;
        uint256 reward = earned(msg.sender, id);
        require(reward>0,"no Rewards Available");
        Stakers[msg.sender][id].lastUpdatedTime = block.timestamp;
        if (reward > 0) {
            Stakers[msg.sender][id].rewardEarned = 0;
            Stakers[msg.sender][id].rewardPaidOut += reward;
            givenRewards+=reward;
            rewardToken.transfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

     function exit(uint id,Whitelist memory stakeo) external isblocklist(msg.sender){
        require(!usedNonce[msg.sender][stakeo.timestamp],"Nonce : Invalid Nonce");
        require (getSigner(stakeo) == signer,'!Signer');
        usedNonce[msg.sender][stakeo.timestamp] = true;
        require(block.timestamp >= Stakers[msg.sender][id].maxTime, "Tokens are locked! Try unstaking after locking period");
         uint amount = Stakers[msg.sender][id].balance;
        require(amount>0,"No staked Balance");
        uint256 reward = earned(msg.sender, id);
        Stakers[msg.sender][id].lastUpdatedTime = block.timestamp;
        if (reward > 0) {
            Stakers[msg.sender][id].rewardEarned = 0;
            givenRewards+=reward;
            Stakers[msg.sender][id].rewardPaidOut += reward;
            rewardToken.transfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
         _totalSupply -=amount;
        Stakers[msg.sender][id].balance = 0;
        stakeToken.transfer(msg.sender, amount);
          emit Unstaked(msg.sender, amount);
    }


    function TotalValueLocked() public view returns (uint256) {
        return _totalSupply;
    }

    function setsigner(address _addr) external onlyOwner{
        signer=_addr;
    }

    function balanceOf(address account, uint id) public view returns (uint256) {
        return Stakers[account][id].balance;
    }

    function recoverExcessToken(address token, uint256 amount) external onlyOwner {
        IERC20Upgradeable(token).transfer(msg.sender, amount);
        emit RecoverToken(token, amount);
    }

    function depositRewards(uint amount) public onlyOwner {
        stakeToken.transferFrom(msg.sender, address(this), amount);
        totalRewardFunds += amount;
        rewardBalance += amount;
    }
    function TotalRewards() public view returns(uint256){
        uint256 tRewards = totalRewardFunds - rewardBalance;
        return tRewards;
    }
    
    function blocklistUsers(address _addr) external onlyOwner{
        isBlocklisted[_addr]=true;
    }
    function unblockUsers(address _addr) external onlyOwner{
         isBlocklisted[_addr]=false;
    }
    function initialize(address _stakeToken, address _RewardToken) external initializer{
          stakeToken=IERC20Upgradeable(_stakeToken);
          rewardToken=IERC20Upgradeable(_RewardToken);
              __Ownable_init();
           signer=msg.sender;
    }
    function setTokens(address _addr) external onlyOwner{
         stakeToken=IERC20Upgradeable(_addr);
         rewardToken=IERC20Upgradeable(_addr);
    }

}