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

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? Что вы сделали, чтобы решить проблему? Дайте нам знать в разделе комментариев ниже.

Вы получаете сообщение об ошибке «Не могу оценить газ» на PancakeSwap?

Вот полное сообщение об ошибке : «Транзакция не может быть выполнена из-за ошибки: невозможно оценить газ».

Затем следует «The transcation cannot succeed due to erro: vannot estimate gas: transactiob may fail or may require manual gasl limit».

Сообщение об ошибке не позволяет вам купить или продать токен.

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