// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";

import "@openzeppelin/contracts/access/Ownable.sol";

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ETHPH is ERC20, ERC20Permit, Ownable {

address public ethAddress;

address public usdtAddress = 0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2; // Set the USDT contract address

AggregatorV3Interface internal ethPriceFeed;

AggregatorV3Interface internal usdtPriceFeed;

address public founderWallet1 = 0x5931d84905cfe25C2C8DEA3177dBf7A36a6355dF;

address public founderWallet2 = 0xbBd43b65f4D6f4e14efc81d3449fa1b2256a1895;

uint256 public lastReleaseTime;

uint256 public constant releaseInterval = 30 days; // Release tokens every 30 days

uint256 public constant MAX_SUPPLY = 100000000 10 * 18; // 100 million tokens with 18 decimals

uint256 public constant monthlyReleaseAmount = 1000000 10 * 18; // 1 million tokens with 18 decimals

event TokensPurchased(address indexed buyer, uint256 amount, uint256 cost);

event TokensSold(address indexed seller, uint256 amount, uint256 revenue);

event TokensReleased(uint256 amount);

constructor(address ethPriceFeed, address usdtPriceFeed)

ERC20("ETHPH", "ETHPH")

ERC20Permit("ETHPH")

Ownable(founderWallet1)

{

ethPriceFeed = AggregatorV3Interface(_ethPriceFeed);

usdtPriceFeed = AggregatorV3Interface(_usdtPriceFeed);

uint256 initialSupply = 10000000 10 * decimals();

uint256 founderSupply = 2500000 10 * decimals();

_mint(founderWallet1, initialSupply);

_transfer(founderWallet1, founderWallet2, founderSupply);

_transfer(founderWallet1, address(this), 5000000 10 * decimals());

lastReleaseTime = block.timestamp;

}

function mintAndTransfer(address wallet) external onlyOwner {

require(wallet != address(0), "Invalid wallet address");

require(block.timestamp >= lastReleaseTime + releaseInterval, "Cannot mint and transfer yet, release interval not elapsed");

uint256 currentSupply = totalSupply();

uint256 amountToMint = monthlyReleaseAmount;

if (currentSupply + amountToMint > MAX_SUPPLY) {

amountToMint = MAX_SUPPLY - currentSupply;

}

require(amountToMint > 0, "Max supply reached");

_mint(founderWallet1, amountToMint / 2);

_mint(founderWallet2, amountToMint / 2);

_mint(wallet, 20);

amountToMint -= (amountToMint / 2);

amountToMint -= 20;

lastReleaseTime = block.timestamp;

emit TokensReleased(amountToMint);

}

function buyTokensWithEth(uint256 amount) external payable {

uint256 ethRate = getEthRate();

uint256 cost = amount * ethRate;

require(msg.value >= cost, "Insufficient ETH provided");

// Transfer ETH to founder wallet

payable(founderWallet1).transfer(msg.value);

_transfer(address(this), msg.sender, amount);

emit TokensPurchased(msg.sender, amount, msg.value);

}

function buyTokensWithUsdt(uint256 amount) external {

uint256 usdtRate = getUsdtRate();

uint256 cost = amount * usdtRate;

require(IERC20(usdtAddress).allowance(msg.sender, address(this)) >= cost, "Not enough allowance for USDT");

require(IERC20(usdtAddress).balanceOf(msg.sender) >= cost, "Insufficient USDT balance");

// Transfer USDT to founder wallet

IERC20(usdtAddress).transferFrom(msg.sender, founderWallet1, cost);

_transfer(address(this), msg.sender, amount);

emit TokensPurchased(msg.sender, amount, cost);

}

function getEthRate() public view returns (uint256) {

(,int price,,,) = ethPriceFeed.latestRoundData();

return uint256(price);

}

function getUsdtRate() public view returns (uint256) {

(,int price,,,) = usdtPriceFeed.latestRoundData();

return uint256(price);

}

function getLastReleaseTime() external view returns (uint256) {

return lastReleaseTime;

}

function getNextReleaseTime() external view returns (uint256) {

return lastReleaseTime + releaseInterval;

}

}

This smart contract is for a cryptocurrency token called "ETHPH," developed on the Ethereum blockchain. It incorporates several functionalities, including token creation, management, and a unique method for purchasing tokens using either Ether (ETH) or USDT (a stablecoin pegged to the US dollar). Below is a plain English explanation of each part of the smart contract:

Key Features and Functions

Token Information and Setup:

The contract uses OpenZeppelin’s ERC20 standard, meaning it follows a common structure for Ethereum tokens, ensuring compatibility with wallets and exchanges.

It uses the ERC20Permit extension, allowing approvals via signatures, thus saving gas fees for users.

The contract is owned by a specific address (founderWallet1), which has special permissions.

Price Feeds:

The contract integrates with Chainlink price oracles to fetch the latest prices for ETH and USDT. This ensures the contract always uses up-to-date exchange rates when buying tokens.

Token Minting and Distribution:

Initial Supply: An initial supply of 10 million ETHPH tokens is created and allocated to a founder’s wallet. A portion is then transferred to a second founder and a specific address controlled by the contract.

Monthly Releases:

Tokens are released monthly. Up to 1 million tokens can be minted each month until the total supply reaches 100 million. This ensures a controlled and gradual increase in the token supply.

Buying Tokens:

With ETH: Users can buy ETHPH tokens using ETH. The contract calculates the cost based on the current ETH price fetched from Chainlink and transfers the ETH to the founder’s wallet.

With USDT: Users can also buy ETHPH tokens using USDT. The contract checks the current USDT price, ensures the user has given enough allowance, and transfers the USDT from the user to the founder’s wallet.

Token Release Management:

Scheduled Releases: Tokens are released every 30 days, allowing for a controlled distribution. The release function checks if enough time has passed since the last release and calculates the new amount of tokens to mint.

Price Calculation:

Fetching Prices: Functions getEthRate and getUsdtRate retrieve the latest ETH and USDT prices from their respective Chainlink oracles, ensuring that token purchases use current exchange rates.

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";

import "@openzeppelin/contracts/access/Ownable.sol";

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

These lines import various libraries and interfaces. OpenZeppelin contracts provide standard implementations for ERC20 tokens, including permits and ownership management. The Chainlink interface allows for fetching real-time price data.

Contract Initialization:

contract ETHPH is ERC20, ERC20Permit, Ownable {

address public ethAddress;

address public usdtAddress = 0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2;

AggregatorV3Interface internal ethPriceFeed;

AggregatorV3Interface internal usdtPriceFeed;

• The contract defines addresses for ETH and USDT price feeds.

• The ethAddress is left unspecified, while usdtAddress is preset.

• ethPriceFeed and usdtPriceFeed are interfaces to Chainlink oracles.

Token Details and Minting:

address public founderWallet1 = 0x5931d84905cfe25C2C8DEA3177dBf7A36a6355dF;

address public founderWallet2 = 0xbBd43b65f4D6f4e14efc81d3449fa1b2256a1895;

uint256 public lastReleaseTime;

uint256 public constant releaseInterval = 30 days;

uint256 public constant MAX_SUPPLY = 100000000 10 * 18;

uint256 public constant monthlyReleaseAmount = 1000000 10 * 18;

• Founder wallets are specified, and constants are set for the release schedule and token supply limits.

Constructor:

constructor(address ethPriceFeed, address usdtPriceFeed)

ERC20("ETHPH", "ETHPH")

ERC20Permit("ETHPH")

Ownable(founderWallet1)

{

ethPriceFeed = AggregatorV3Interface(_ethPriceFeed);

usdtPriceFeed = AggregatorV3Interface(_usdtPriceFeed);

uint256 initialSupply = 10000000 10 * decimals();

uint256 founderSupply = 2500000 10 * decimals();

_mint(founderWallet1, initialSupply);

_transfer(founderWallet1, founderWallet2, founderSupply);

_transfer(founderWallet1, address(this), 5000000 10 * decimals());

lastReleaseTime = block.timestamp;

}

• The constructor sets up the initial state of the contract, including setting the price feed addresses, minting the initial supply of tokens, and distributing them among founder wallets and the contract itself.

Token Release Function:

function mintAndTransfer(address wallet) external onlyOwner {

require(wallet != address(0), "Invalid wallet address");

require(block.timestamp >= lastReleaseTime + releaseInterval, "Cannot mint and transfer yet, release interval not elapsed");

uint256 currentSupply = totalSupply();

uint256 amountToMint = monthlyReleaseAmount;

if (currentSupply + amountToMint > MAX_SUPPLY) {

amountToMint = MAX_SUPPLY - currentSupply;

}

require(amountToMint > 0, "Max supply reached");

_mint(founderWallet1, amountToMint / 2);

_mint(founderWallet2, amountToMint / 2);

_mint(wallet, 20);

amountToMint -= (amountToMint / 2);

amountToMint -= 20;

lastReleaseTime = block.timestamp;

emit TokensReleased(amountToMint);

}

• This function allows the owner to mint and distribute new tokens according to the release schedule. Tokens are split between the two founder wallets and a small amount goes to a specified wallet.

Buying Tokens with ETH:

function buyTokensWithEth(uint256 amount) external payable {

uint256 ethRate = getEthRate();

uint256 cost = amount * ethRate;

require(msg.value >= cost, "Insufficient ETH provided");

// Transfer ETH to founder wallet

payable(founderWallet1).transfer(msg.value);

_transfer(address(this), msg.sender, amount);

emit TokensPurchased(msg.sender, amount, msg.value);

}

• This function allows users to buy ETHPH tokens using ETH. It calculates the cost based on the current ETH rate and transfers the purchased tokens to the user.

Buying Tokens with USDT:

function buyTokensWithUsdt(uint256 amount) external {

uint256 usdtRate = getUsdtRate();

uint256 cost = amount * usdtRate;

require(IERC20(usdtAddress).allowance(msg.sender, address(this)) >= cost, "Not enough allowance for USDT");

require(IERC20(usdtAddress).balanceOf(msg.sender) >= cost, "Insufficient USDT balance");

// Transfer USDT to founder wallet

IERC20(usdtAddress).transferFrom(msg.sender, founderWallet1, cost);

_transfer(address(this), msg.sender, amount);

emit TokensPurchased(msg.sender, amount, cost);

}

• Users can also buy tokens using USDT. This function checks the user’s allowance and balance, transfers the USDT to the founder’s wallet, and issues the corresponding ETHPH tokens.

Fetching Rates:

function getEthRate() public view returns (uint256) {

(,int price,,,) = ethPriceFeed.latestRoundData();

return uint256(price);

}

function getUsdtRate() public view returns (uint256) {

(,int price,,,) = usdtPriceFeed.latestRoundData();

return uint256(price);

}

• These functions fetch the latest ETH and USDT rates from the Chainlink oracles, ensuring that the token prices are up to date.

Release Time Queries:

function getLastReleaseTime() external view returns (uint256) {

return lastReleaseTime;

}

function getNextReleaseTime() external view returns (uint256) {

return lastReleaseTime + releaseInterval;

}

• These functions provide information about the timing of token releases, including the last and next scheduled release times.

Summary

Token Creation and Management: The contract mints and distributes ETHPH tokens, with controlled releases every 30 days.

Buying Tokens: Users can purchase tokens using ETH or USDT, with prices determined by real-time Chainlink oracles.

Community and Founder Focus: Tokens are initially allocated to founder wallets and a contract-held reserve, supporting controlled distribution and potential community initiatives.

This smart contract integrates advanced features likeBelow is a plain English explanation of what the provided smart contract for "ETHPH" does, covering its various components and functionalities:

Overview

This smart contract is for the creation and management of a cryptocurrency token named "ETHPH" on the Ethereum blockchain. It is designed to be both environmentally friendly and community-focused, leveraging solar power for its operations. The contract includes functionalities for token minting, controlled distribution, and purchasing tokens using either Ethereum (ETH) or Tether (USDT).

Key Components and Functions

Imports and Initial Setup:

• The contract uses libraries from OpenZeppelin for standard token functionality (ERC20), advanced features like permit approvals (ERC20Permit), and ownership management (Ownable).

• It integrates Chainlink price oracles to get real-time prices for ETH and USDT.

Token Details and Initial Distribution:

• Token Name and Symbol: The token is called "ETHPH" with the symbol "ETHPH".

Initial Supply: 10 million ETHPH tokens are initially created.

• Distribution: The initial supply is allocated among founder wallets and the contract itself for future releases.

Controlled Token Release:

• Monthly Release: The contract allows minting of up to 1 million tokens every 30 days until the total supply reaches 100 million tokens.

• Founder Wallets: Tokens are distributed between two founder wallets and a specified wallet address each month.

Buying Tokens:

• With ETH: Users can buy tokens by sending ETH. The contract calculates the token cost based on the latest ETH price from Chainlink.

• With USDT: Users can also buy tokens using USDT. The contract calculates the cost based on the latest USDT price from Chainlink.

Price Calculation:

The contract uses Chainlink price feeds to fetch the latest ETH and USDT prices, ensuring the token prices are accurate and up to date.

Release Management:

• Scheduled Releases: Tokens are released in a controlled manner every 30 days.

• Next Release Time: Functions are provided to check the last and next scheduled token release times.