I have implemented a rudimentary protocol for depositing token A into a smart contract on the BSC Testnet using Remix. First, we specified the IERC20 token address and created two functions to try and deposit it into the smart contract; stake and stake2. Stake uses the transferFrom function (with approval being sought) and stake2 tries to do the same thing but with a transfer function. Both of these throw up errors.
In the case of stake, it throws up that "transfer amount exceeds allowance", despite the fact that the amount being transferred is less than the balance.
In the case of stake2, it throws up an execution reverted error that 'SafeMath: subtraction overflow".
pragma solidity 0.5.8;
contract TOKENStaking {
using SafeMath for uint256;
IERC20 constant TOKEN = IERC20(0x0A796f363Db8CBDD25F4332583A3AEEE11666Ddf); // Token A
function stake(uint amount) external {
uint256 balance = TOKEN.balanceOf(msg.sender);
require(balance > 0 && balance >= amount && amount > 0 );
IERC20(TOKEN).approve(msg.sender, amount);
IERC20(TOKEN).transferFrom(msg.sender,address(this),amount);
}
function stake2(uint amount) external {
uint256 balance = TOKEN.balanceOf(msg.sender);
require(balance > 0 && balance >= amount && amount > 0 );
IERC20(TOKEN).transfer(address(this),amount);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, 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 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);
}
library SafeMath {
/**
* @dev Multiplies two numbers, throws on overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
I feel like I am missing something really obvious here. Can anyone point me in the right direction?