Warning error encountered during contract execution out of gas что делать

contract FutureContractFactory {
    address[] public deployedContracts;

function createFutureContract(string _title, uint _contractSize, uint _endDate) public returns (FutureContract) {
    FutureContract newContract = new FutureContract(_title, _contractSize, _endDate, msg.sender);
    deployedContracts.push(newContract);
    return newContract;
}

function getContractsAmount() public view returns (uint) {
    return deployedContracts.length;
}

struct BuyOrder {
    address buyer;
    bytes32 key;
    uint contractsAmount;
    uint depositedEther; //wei
    uint margin;
    uint dealPrice; //* 100
    uint fees; //wei
}

struct SellOrder {
    address seller;
    bytes32 key;
    uint contractsAmount;
    uint depositedEther; //wei
    uint margin;
    uint dealPrice; //* 100
    uint fees; //wei
}

struct Trade {
    bytes32 key;
    bytes32 buyOrderKey;
    bytes32 sellOrderKey;
    uint sellerExitEtherAmount; //wei
    uint buyerExitEtherAmount; //wei
    State status;
}

struct ContractParams {
    address owner;
    uint endDate;
    uint contractSize; //in wei
    string title;
}

ContractParams public contractParams;
mapping(address => uint) public balance;
mapping(bytes32 => Trade) private tradesMap;
mapping(bytes32 => SellOrder) private sellOrdersMap;
mapping(bytes32 => BuyOrder) private buyOrdersMap;

modifier restricted() {
    require(msg.sender == contractParams.owner, "Only allowed to manager");
    _;
}

modifier isValid() {
    require(contractParams.endDate <= now, "Wait for expiration date");
    _;
}

constructor(string _title, uint _contractSize, uint _endDate, address manager) public {
    contractParams.owner = manager;
    contractParams.contractSize = _contractSize;
    contractParams.endDate = _endDate;
    contractParams.title = _title;
}

function createBuyOrder(
    string key,
    uint contractsAmount,
    uint margin,
    uint dealPrice
    ) payable public {

    require(msg.value >= contractsAmount * contractParams.contractSize, "Insufficient deposit");
    require(msg.sender != contractParams.owner, "Manager can not bid");
    require (now < contractParams.endDate, "End date expired");

    bytes32 keyByte = keccak256(bytes(key));
    uint fees = calculateFee(msg.value);
    createBuyOrder(keyByte, contractsAmount, margin, dealPrice, msg.value, fees);
}

function createBuyOrder(
    bytes32 key,
    uint contractsAmount,
    uint margin,
    uint dealPrice,
    uint depositedEther,
    uint fees
    ) private {

    BuyOrder memory newBuyOrder = BuyOrder({
        buyer: msg.sender,
        key: key,
        contractsAmount: contractsAmount,
        dealPrice: dealPrice,
        margin: margin,
        depositedEther: depositedEther,
        fees: fees
    });
    buyOrdersMap[key] = newBuyOrder;
    balance[contractParams.owner] += fees;
}

function getBuyOrder(string key) public view returns(address, uint, uint, uint, uint) {
    bytes32 keyByte = keccak256(bytes(key));
    return (buyOrdersMap[keyByte].buyer, buyOrdersMap[keyByte].contractsAmount, buyOrdersMap[keyByte].depositedEther, buyOrdersMap[keyByte].fees, buyOrdersMap[keyByte].dealPrice);

}

function createSellOrder(
    string key,
    uint contractsAmount,
    uint margin,
    uint dealPrice
    ) payable public {

    require(msg.value >= contractsAmount * contractParams.contractSize, "Insufficient deposit");
    require(msg.sender != contractParams.owner, "Manager can not bid");
    require (now < contractParams.endDate, "End date expired");

    bytes32 keyByte = keccak256(bytes(key));
    uint fees = calculateFee(msg.value);
    createSellOrder(keyByte, contractsAmount, margin, dealPrice, msg.value, fees);
}

function createSellOrder(
    bytes32 key,
    uint contractsAmount,
    uint margin,
    uint dealPrice,
    uint depositedEther,
    uint fees
    ) private {

    SellOrder memory newSellOrder = SellOrder({
        seller: msg.sender,
        key: key,
        contractsAmount: contractsAmount,
        dealPrice: dealPrice,
        margin: margin,
        depositedEther: depositedEther,
        fees: fees
    });
    sellOrdersMap[key] = newSellOrder;
    balance[contractParams.owner] += fees;
}

function getSellOrder(string key) public view returns(address, uint, uint, uint, uint) {
    bytes32 keyByte = keccak256(bytes(key));
    return (sellOrdersMap[keyByte].seller, sellOrdersMap[keyByte].contractsAmount, sellOrdersMap[keyByte].depositedEther, sellOrdersMap[keyByte].fees, sellOrdersMap[keyByte].dealPrice);

}

function createTrade(string tradeKey, string buyOrderKey, string sellOrderKey) restricted public  {
  bytes32 tradeByte = keccak256(bytes(tradeKey));
  bytes32 buyByte = keccak256(bytes(buyOrderKey));
  bytes32 sellByte = keccak256(bytes(sellOrderKey));
  createTrade(tradeByte, buyByte, sellByte);
}

function createTrade(bytes32 tradeKey, bytes32 buyOrderKey, bytes32 sellOrderKey) private {

    require(buyOrdersMap[buyOrderKey].depositedEther > 0, "Must have a buy order created");
    require(sellOrdersMap[sellOrderKey].depositedEther > 0, "Must have a sell order created");
    require(sellOrdersMap[sellOrderKey].dealPrice <= buyOrdersMap[buyOrderKey].dealPrice, "DealPrice does not match");
    require(sellOrdersMap[sellOrderKey].seller != buyOrdersMap[buyOrderKey].buyer, "Buyer and seller must be different");
    require (now <= contractParams.endDate, "End date expired");

    Trade memory newTrade = Trade({
        key: tradeKey,
        buyOrderKey: buyOrderKey,
        sellOrderKey: sellOrderKey,
        sellerExitEtherAmount: 1,
        buyerExitEtherAmount: 1,
        status: State.Created
    });

    tradesMap[tradeKey] = newTrade;
}

function getTrade(string key) public view returns(uint, uint, uint) {
    bytes32 keyByte = keccak256(bytes(key));
    return (
      tradesMap[keyByte].sellerExitEtherAmount,
      tradesMap[keyByte].buyerExitEtherAmount,
      uint(tradesMap[keyByte].status));
}

function getStorageVars() public view returns(uint, uint, string) {
    return (contractParams.endDate, contractParams.contractSize, contractParams.title);
}

function calculateFee(uint etherValue) private pure returns(uint) {
    return (etherValue/1000);
}

INSUFFICIENT_OUTPUT_AMOUNT

The transaction cannot succeed due to error: PancakeRouter: INSUFFICIENT_OUTPUT_AMOUNT. This is probably an issue with one of the tokens you are swapping.

Вы пытаетесь обменять токен, но выставили слишком низкий коэфициент проскальзивания. Сделка также может не пройти из-за низкой ликвидности..

INSUFFICIENT_A_AMOUNT or INSUFFICIENT_B_AMOUNT

Fail with error ‘PancakeRouter: INSUFFICIENT_A_AMOUNT’
or
Fail with error ‘PancakeRouter: INSUFFICIENT_B_AMOUNT’

Вы пытаетесь добавить/убрать ликвидность из пула ликвидности (LP), но вам не хватает одного из двух токенов в паре.

The transaction cannot succeed due to error: PancakeRouter: EXPIRED. This is probably an issue with one of the tokens you are swapping.

Попробуйте еще раз, но при этом подтвердите (подпишите и отправьте в сеть) транзакцию как только её сгенерируете.

Подобное может случиться, если вы начали сделку, но не закончили её вовремя. Постарайтесь сразу нажать кнопку «Confirm».

The transaction cannot succeed due to error: Pancake: K. This is probably an issue with one of the tokens you are swapping.

Обновите страницу и попробуйте снова. Увеличьте коэфициент проскальзывания.

Вероятнее всего, в момент сделки слишком быстро изменилась цена токена. Подобное происходит в периоды сильной волотильности и ажиотажа на рынке. Сайт может отображать устаревшую информацию из смартконтракта (цена/кол-во токенов к покупке). По этой причине сделка может не состояться.

BEP20: burn amount exceeds balance

Fail with error ‘BEP20: burn amount exceeds balance’

Вам не хватает токенов SYRUP для снятия CAKE из пула.

Warning! Error encountered during contract execution [out of gas]

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

BEP20: transfer amount exceeds balance

Fail with error ‘BEP20: transfer amount exceeds balance’

Вы пытаетесь выйти из SYRUP пула с низким вознаграждением (не хватает наград).