// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)pragmasolidity ^0.8.20;/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/abstractcontractContext{
function_msgSender() internalviewvirtualreturns (address) {
returnmsg.sender;
}
function_msgData() internalviewvirtualreturns (bytescalldata) {
returnmsg.data;
}
function_contextSuffixLength() internalviewvirtualreturns (uint256) {
return0;
}
}
Contract Source Code
File 3 of 5: IERC20.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)pragmasolidity ^0.8.20;/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/interfaceIERC20{
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/eventTransfer(addressindexedfrom, addressindexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/eventApproval(addressindexed owner, addressindexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/functiontotalSupply() externalviewreturns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/functionbalanceOf(address account) externalviewreturns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/functiontransfer(address to, uint256 value) externalreturns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/functionallowance(address owner, address spender) externalviewreturns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/functionapprove(address spender, uint256 value) externalreturns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/functiontransferFrom(addressfrom, address to, uint256 value) externalreturns (bool);
}
Contract Source Code
File 4 of 5: Ownable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)pragmasolidity ^0.8.20;import {Context} from"../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/abstractcontractOwnableisContext{
addressprivate _owner;
/**
* @dev The caller account is not authorized to perform an operation.
*/errorOwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/errorOwnableInvalidOwner(address owner);
eventOwnershipTransferred(addressindexed previousOwner, addressindexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/constructor(address initialOwner) {
if (initialOwner ==address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/modifieronlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/functionowner() publicviewvirtualreturns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/function_checkOwner() internalviewvirtual{
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/functionrenounceOwnership() publicvirtualonlyOwner{
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/functiontransferOwnership(address newOwner) publicvirtualonlyOwner{
if (newOwner ==address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/function_transferOwnership(address newOwner) internalvirtual{
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
Contract Source Code
File 5 of 5: PorkPresale.sol
// SPDX-License-Identifier: MITimport {AggregatorV3Interface} from"@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
import {IERC20} from"@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from"@openzeppelin/contracts/access/Ownable.sol";
pragmasolidity ^0.8.20;interfaceIUSDT{
functiontransferFrom(address _from, address _to, uint _value) external;
functionbalanceOf(address who) externalreturns (uint);
functiontransfer(address _to, uint _value) external;
}
contractPORKPresaleisOwnable{
uint256public initialPrice =0.00001ether;
uint256public fixedPrice;
uint256public finalPrice;
uint256public tokensSold =0;
uint256public presaleSupply =0;
uint256public startTime;
boolpublic staticPrice =false;
boolpublic initialize =false;
boolpublic halfSupplySold =false;
structuserBalance {
uint256 balance;
uint256 claimed;
}
mapping(address=> userBalance) public userBalances;
AggregatorV3Interface private dataFeed; //Chainlink AggregatorV3 for ETH/USD Price
IUSDT usdt;
IERC20 token;
constructor(address _token, uint256 _presaleSupply) Ownable(msg.sender) {
dataFeed = AggregatorV3Interface(
0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
);
usdt = IUSDT(0xdAC17F958D2ee523a2206206994597C13D831ec7);
token = IERC20(_token);
presaleSupply = _presaleSupply;
}
/** Buy PORK
@param _amount the value of ETH or USD to be spent to buy PORK Tokens
@param _id 0 is for ETH, 1 for USDT
@dev swaps ETH/USDT for PORK
**/functionbuyPORK(uint256 _amount, uint8 _id) externalpayable{
//usdt and usdc is 6 decimal placesrequire(initialize, "Presale has not been initialized.");
uint256 halfSupply = presaleSupply /2;
if(tokensSold >= halfSupply &&!halfSupplySold){
finalPrice = getCurrentRate();
halfSupplySold =true;
}
if (_id ==0) {
//ETHEREUMuint256 valueSent =msg.value;
require(valueSent >0, "Cannot buy PORK with zero ether/usd");
uint256 _amountToReceiveInUSD = getConversionRate(valueSent);
uint256 _amountToSend = getPORKSaleAmountForETH(
_amountToReceiveInUSD
);
tokensSold += _amountToSend;
userBalances[msg.sender].balance+= _amountToSend;
(bool success, ) = owner().call{value: valueSent}("");
require(success);
} elseif (_id ==1) {
//USDTrequire(_amount >0, "Cannot buy PORK with zero ether/usd");
uint256 _amountToReceive = _amount;
uint256 _amountToSend = getPORKSaleAmountForUSD(_amount);
require(
usdt.balanceOf(msg.sender) >= _amountToReceive,
"PORK: USDT Transfer exceeds balance"
);
tokensSold += _amountToSend;
userBalances[msg.sender].balance+= _amountToSend;
usdt.transferFrom(msg.sender, address(this), _amountToReceive);
usdt.transfer(owner(), _amountToReceive);
}
}
functionclaim() external{
uint256 _amountToSend = userBalances[msg.sender].balance- userBalances[msg.sender].claimed;
require(_amountToSend >0, "You've already claimed your PORK Tokens.");
require(token.balanceOf(address(this)) >= _amountToSend, "PORK: Transfer exceeds contract balance of PORK.");
userBalances[msg.sender].claimed +=_amountToSend;
token.transfer(msg.sender, _amountToSend);
}
functiongetPORKSaleAmountForETH(uint256 baseAmount)
publicviewreturns (uint256)
{
uint256 price = getCurrentRate();
return (baseAmount *10**18) / price;
}
functiongetPORKSaleAmountForUSD(uint256 baseAmount)
publicviewreturns (uint256)
{
uint256 price = getCurrentRate();
return (baseAmount *10**30) / price;
}
functiongetETHPrice() internalviewreturns (uint256) {
(, int256 answer, , , ) = dataFeed.latestRoundData();
// ETH/USD rate in 18 digitreturnuint256(answer *10000000000);
}
functiongetConversionRate(uint256 ethAmount)
publicviewreturns (uint256)
{
uint256 ethPrice = getETHPrice();
uint256 ethAmountInUsd = (ethPrice * ethAmount) /1000000000000000000;
// the actual ETH/USD conversation rate, after adjusting the extra 0s.return ethAmountInUsd;
}
functiongetCurrentRate()
publicviewreturns (uint256)
{
if (staticPrice){
return fixedPrice;
}
if (halfSupplySold) {
return finalPrice;
}
// Calculate the number of days passeduint256 daysPassed = (block.timestamp- startTime) /1days;
// Calculate the price after 5% increase every dayuint256 currentPrice = initialPrice;
for (uint256 i =0; i < daysPassed; i++) {
currentPrice = currentPrice + (currentPrice *5) /100;
}
return currentPrice;
}
// Function to get the seconds left till the next price hikefunctiongetSecondsUntilNextHike() publicviewreturns (uint256) {
// Calculate the number of days passed since the start timeuint256 daysPassed = (block.timestamp- startTime) /1days;
// Calculate the time of the next hikeuint256 nextHikeTime = startTime + ((daysPassed +1) *1days);
// Calculate the seconds remaining until the next hikeif (block.timestamp< nextHikeTime) {
return nextHikeTime -block.timestamp;
} else {
// If current time is beyond the next hike time, return 0return0;
}
}
functionsetPresaleSupply(uint256 _amount) publiconlyOwner{
presaleSupply = _amount;
}
functionwithdrawPreSaleTokens(uint256 _amount) externalonlyOwner{
require(
token.balanceOf(address(this)) >= _amount,
"PORK: Transfer exceeds contract balance"
);
token.transfer(msg.sender, _amount);
}
functionchangeInitialPrice(uint256 _price) publiconlyOwner{
initialPrice = _price;
}
functionsetFixedPrice(uint256 _price, bool _status) publiconlyOwner{
staticPrice = _status;
fixedPrice = _price;
}
functioncorrectStartTime(uint256 _time) publiconlyOwner{
startTime = _time;
}
functioninitializePresale(uint256 _startTime, bool _initialize) publiconlyOwner{
startTime = _startTime;
initialize = _initialize;
}
functionwithdrawEther() externalonlyOwner{
(bool success, ) =msg.sender.call{value: address(this).balance}("");
require(success);
}
functionwithdrawToken(address _tokenAddress) externalonlyOwner{
IERC20(_tokenAddress).transfer(
msg.sender,
IERC20(_tokenAddress).balanceOf(address(this))
);
}
}