i want to multi-send bep20 token to many address, but i cant find a way to do it. is there any problem in the code?
here is the code…
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// File: @openzeppelin/contracts/utils/Pausable.sol
abstract contract Pausable is Context {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
constructor () internal {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
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);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
/**
* @dev Collection of functions related to the address type
*/
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
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");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File: contracts/Escapable.sol
contract Escapable is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
/// @notice The `escapeHatch()` should only be called as a last resort if a
/// security issue is uncovered or something unexpected happened
/// @param _token to transfer, use 0x0 for ether
function escapeHatch(address _token, address payable _escapeHatchDestination) external onlyOwner nonReentrant {
require(_escapeHatchDestination != address(0x0));
uint256 balance;
/// @dev Logic for ether
if (_token == address(0x0)) {
balance = address(this).balance;
_escapeHatchDestination.transfer(balance);
EscapeHatchCalled(_token, balance);
return;
}
// Logic for tokens
IERC20 token = IERC20(_token);
balance = token.balanceOf(address(this));
token.safeTransfer(_escapeHatchDestination, balance);
emit EscapeHatchCalled(_token, balance);
}
event EscapeHatchCalled(address token, uint256 amount);
}
// File: contracts/MultiTransfer.sol
/// @notice Transfer Ether to multiple addresses
contract MultiTransfer is Pausable {
using SafeMath for uint256;
/// @notice Send to multiple addresses using two arrays which
/// includes the address and the amount.
/// Payable
/// @param _addresses Array of addresses to send to
/// @param _amounts Array of amounts to send
function multiTransfer_OST(address payable[] calldata _addresses, uint256[] calldata _amounts)
payable external whenNotPaused returns(bool)
{
// require(_addresses.length == _amounts.length);
// require(_addresses.length <= 255);
uint256 _value = msg.value;
for (uint8 i; i < _addresses.length; i++) {
_value = _value.sub(_amounts[i]);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
/*(success, ) = */_addresses[i].call{ value: _amounts[i] }("");
// we do not care. caller should check sending results manually and re-send if needed.
}
return true;
}
/// @notice Send to two addresses
/// Payable
/// @param _address1 Address to send to
/// @param _amount1 Amount to send to _address1
/// @param _address2 Address to send to
/// @param _amount2 Amount to send to _address2
function transfer2(address payable _address1, uint256 _amount1, address payable _address2, uint256 _amount2)
payable external whenNotPaused returns(bool)
{
uint256 _value = msg.value;
_value = _value.sub(_amount1);
_value = _value.sub(_amount2);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
/*(success, ) = */_address1.call{ value: _amount1 }("");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
/*(success, ) = */_address2.call{ value: _amount2 }("");
return true;
}
}
// File: contracts/MultiTransferEqual.sol
*/
/// @notice Transfer equal Ether amount to multiple addresses
contract MultiTransferEqual is Pausable {
/// @notice Send equal Ether amount to multiple addresses.
/// Payable
/// @param _addresses Array of addresses to send to
/// @param _amount Amount to send
function multiTransferEqual_L1R(address payable[] calldata _addresses, uint256 _amount)
payable external whenNotPaused returns(bool)
{
// assert(_addresses.length <= 255);
require(_amount <= msg.value / _addresses.length);
for (uint8 i; i < _addresses.length; i++) {
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
/*(success, ) = */_addresses[i].call{ value: _amount }("");
// we do not care. caller should check sending results manually and re-send if needed.
}
return true;
}
}
// File: contracts/MultiTransferToken.sol
/// @notice Transfer tokens to multiple addresses
contract MultiTransferToken is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Send ERC20 tokens to multiple addresses
/// using two arrays which includes the address and the amount.
///
/// @param _token The token to send
/// @param _addresses Array of addresses to send to
/// @param _amounts Array of token amounts to send
/// @param _amountSum Sum of the _amounts array to send
function multiTransferToken_a4A(
address _token,
address[] calldata _addresses,
uint256[] calldata _amounts,
uint256 _amountSum
) payable external whenNotPaused
{
// require(_addresses.length == _amounts.length);
// require(_addresses.length <= 255);
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
_amountSum = _amountSum.sub(_amounts[i]);
token.transfer(_addresses[i], _amounts[i]);
}
}
}
// File: contracts/MultiTransferTokenEqual.sol
/// @notice Transfer equal tokens amount to multiple addresses
contract MultiTransferTokenEqual is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Send equal ERC20 tokens amount to multiple contracts
///
/// @param _token The token to send
/// @param _addresses Array of addresses to send to
/// @param _amount Tokens amount to send to each address
function multiTransferTokenEqual_71p(
address _token,
address[] calldata _addresses,
uint256 _amount
) payable external whenNotPaused
{
// assert(_addresses.length <= 255);
uint256 _amountSum = _amount.mul(_addresses.length);
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
token.transfer(_addresses[i], _amount);
}
}
}
// File: contracts/MultiTransferTokenEther.sol
/// @notice Transfer tokens and Ether to multiple addresses in one call
contract MultiTransferTokenEther is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Send ERC20 tokens and Ether to multiple addresses
/// using three arrays which includes the address and the amounts.
///
/// @param _token The token to send
/// @param _addresses Array of addresses to send to
/// @param _amounts Array of token amounts to send
/// @param _amountsEther Array of Ether amounts to send
function multiTransferTokenEther(
address _token,
address payable[] calldata _addresses,
uint256[] calldata _amounts,
uint256 _amountSum,
uint256[] calldata _amountsEther
) payable external whenNotPaused
{
// assert(_addresses.length == _amounts.length);
// assert(_addresses.length == _amountsEther.length);
// assert(_addresses.length <= 255);
uint256 _value = msg.value;
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
// bool success;
for (uint8 i; i < _addresses.length; i++) {
_amountSum = _amountSum.sub(_amounts[i]);
_value = _value.sub(_amountsEther[i]);
token.transfer(_addresses[i], _amounts[i]);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
/*(success, ) = */_addresses[i].call{ value: _amountsEther[i] }("");
// we do not care. caller should check sending results manually and re-send if needed.
}
}
}
// File: contracts/MultiTransferTokenEtherEqual.sol
/// @notice Transfer equal amounts of tokens and Ether to multiple addresses in one call
contract MultiTransferTokenEtherEqual is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
/// @notice Send equal ERC20 tokens amount to multiple addresses
///
/// @param _token The token to send
/// @param _addresses Array of addresses to send to
/// @param _amount Tokens amount to send to each address
/// @param _amountEther Ether amount to send
function multiTransferTokenEtherEqual(
address _token,
address payable[] calldata _addresses,
uint256 _amount,
uint256 _amountEther
) payable external whenNotPaused
{
// assert(_addresses.length <= 255);
require(_amountEther <= msg.value / _addresses.length);
uint256 _amountSum = _amount.mul(_addresses.length);
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
token.transfer(_addresses[i], _amount);
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
/*(success, ) = */_addresses[i].call{ value: _amountEther }("");
// we do not care. caller should check sending results manually and re-send if needed.
}
}
}
// File: contracts/MultiSend.sol
contract MultiSend is Pausable, Escapable,
MultiTransfer,
MultiTransferEqual,
MultiTransferToken,
MultiTransferTokenEqual,
MultiTransferTokenEther,
MultiTransferTokenEtherEqual
{
/// @dev Emergency stop contract in a case of a critical security flaw discovered
function emergencyStop() external onlyOwner {
_pause();
}
/// @dev Default payable function to not allow sending to contract;
receive() external payable {
revert("Can not accept Ether directly.");
}
/// @dev Notice callers if functions that do not exist are called
fallback() external payable { require(msg.data.length == 0); }
}