title: Problems when buying tokens from a contract using BNB
body: <p>I am creating this smart contract, it creates and adds all tokens to my wallet.
  Then I send all the tokens in my wallet to my contract.</p>
  <p>However, when from another wallet I send BNB for the contract I wanted him to return a number of tokens that are with my contract.</p>
  <p>When I do this the transfer fails and sends the following error message:</p>
  <p><strong>Warning! Error encountered during contract execution [out of gas]</strong></p>
  <p>Queria saber se estou fazendo algo errado, ou como devo fazer para que meu contrato tenha <strong>gas</strong>.</p>
  <p>Transaction Details: <a href="https://testnet.bscscan.com/tx/0x7ef36e49e3c6f77716aee79cefbde6c298c3ddeef16ed12dbe613573661135bb" rel="nofollow noreferrer">https://testnet.bscscan.com/tx/0x7ef36e49e3c6f77716aee79cefbde6c298c3ddeef16ed12dbe613573661135bb</a></p>
  <p>Smart Contract:</p>
  <blockquote>
  <pre><code>pragma solidity ^0.8.0;
  
  interface IERC20 {
  
  function totalSupply() external view returns (uint256);
  function balanceOf(address account) external view returns (uint256);
  function allowance(address owner, address spender) external view returns (uint256);
  
  function transfer(address recipient, uint256 amount) external returns (bool);
  function approve(address spender, uint256 amount) external returns (bool);
  function transferFrom(address sender, address recipient, 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); }
  
  
  contract ERC20Basic is IERC20 {
  
  string public constant name = &quot;ByeSeel&quot;;
  string public constant symbol = &quot;BYS&quot;;
  uint8 public constant decimals = 18;
  
  
  event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
  event Transfer(address indexed from, address indexed to, uint tokens);
  
  
  mapping(address =&gt; uint256) balances;
  
  mapping(address =&gt; mapping (address =&gt; uint256)) allowed;
  
  uint256 totalSupply_ = 100 * 10 ** 18;
  
  using SafeMath for uint256;
  
  constructor() public {
  balances[msg.sender] = totalSupply_;
  }
  
  function totalSupply() public override view returns (uint256) {
  return totalSupply_;
  }
  
  function balanceOf(address tokenOwner) public override view returns (uint256) {
      return balances[tokenOwner];
  }
  
  function transfer(address receiver, uint256 numTokens) public override returns (bool) {
      require(numTokens &lt;= balances[msg.sender]);
      balances[msg.sender] = balances[msg.sender].sub(numTokens);
      balances[receiver] = balances[receiver].add(numTokens);
      emit Transfer(msg.sender, receiver, numTokens);
      return true;
  }
  
  function approve(address delegate, uint256 numTokens) public override returns (bool) {
      allowed[msg.sender][delegate] = numTokens;
      emit Approval(msg.sender, delegate, numTokens);
      return true;
  }
  
  function allowance(address owner, address delegate) public override view returns (uint) {
      return allowed[owner][delegate];
  }
  
  function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
      require(numTokens &lt;= balances[owner]);
      require(numTokens &lt;= allowed[owner][msg.sender]);
  
      balances[owner] = balances[owner].sub(numTokens);
      allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
      balances[buyer] = balances[buyer].add(numTokens);
      emit Transfer(owner, buyer, numTokens);
      return true;
  }
  
  event Received(address, uint);
   receive() external payable {
   emit Received(msg.sender, msg.value);
  }
  
   }
  
  library SafeMath {
  function sub(uint256 a, uint256 b) internal pure returns (uint256) {
    assert(b &lt;= a);
    return a - b;
  }
  
  function add(uint256 a, uint256 b) internal pure returns (uint256) {
    uint256 c = a + b;
    assert(c &gt;= a);
    return c;
  } }
  
  contract DEX {
  
  event Bought(uint256 amount);
  event Sold(uint256 amount);
  
  
  IERC20 public token;
  
  constructor() public {
      token = new ERC20Basic();
  }
  
  function buy() payable public {
      uint256 amountTobuy = msg.value;
      uint256 dexBalance = token.balanceOf(address(this));
      require(amountTobuy &gt; 0, &quot;You need to send some Ether&quot;);
      require(amountTobuy &lt;= dexBalance, &quot;Not enough tokens in the reserve&quot;);
      token.transfer(msg.sender, amountTobuy);
      emit Bought(amountTobuy);
  }
  
  function sell(uint256 amount) public {
      require(amount &gt; 0, &quot;You need to sell at least some tokens&quot;);
      uint256 allowance = token.allowance(msg.sender, address(this));
      require(allowance &gt;= amount, &quot;Check the token allowance&quot;);
      token.transferFrom(msg.sender, address(this), amount);
      msg.sender.transfer(amount);
      emit Sold(amount);
  }
  
  }
  </code></pre>
  </blockquote>