S Price: $0.612129 (+15.61%)
    /

    Contract

    0x20a85a2e0a67EF5BA2B378297D2C8A87359289dc

    Overview

    S Balance

    Sonic LogoSonic LogoSonic Logo0 S

    S Value

    $0.00

    Multichain Info

    No addresses found
    Transaction Hash
    Method
    Block
    Age
    From
    To

    There are no matching entries

    Please try again later

    Parent Transaction Hash Block Age From To Amount
    View All Internal Transactions
    Loading...
    Loading

    Contract Source Code Verified (Exact Match)

    Contract Name:
    FakePools

    Compiler Version
    v0.8.18+commit.87f61d96

    Optimization Enabled:
    Yes with 1337 runs

    Other Settings:
    default evmVersion
    File 1 of 26 : FakePools.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Contracts/Libraries/Modifiers
    import { LibCore } from "../../../libraries/LibCore.sol";
    import { LibFakePools } from "../../../libraries/LibFakePools.sol";
    import { LibTokens } from "../../../libraries/LibTokens.sol";
    import { LibUsd } from "../../../libraries/LibUsd.sol";
    import { Diamondable } from "../../../Diamondable.sol";
    // Facets
    import { Core } from "../Core.sol";
    // Third Party
    import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
    contract FakePools is Diamondable {
    function swapExactTokensForETH(LibFakePools.FakePool storage pool, uint256 tokens) internal returns (uint256) {
    uint256 out = getAmountOut(tokens, pool.tokenReserve, pool.ethReserve + fakeEther());
    pool.tokenReserve += tokens;
    pool.ethReserve -= out;
    return out;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 2 of 26 : ERC20.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
    pragma solidity ^0.8.0;
    import "./IERC20.sol";
    import "./extensions/IERC20Metadata.sol";
    import "../../utils/Context.sol";
    /**
    * @dev Implementation of the {IERC20} interface.
    *
    * This implementation is agnostic to the way tokens are created. This means
    * that a supply mechanism has to be added in a derived contract using {_mint}.
    * For a generic mechanism see {ERC20PresetMinterPauser}.
    *
    * TIP: For a detailed writeup see our guide
    * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
    * to implement supply mechanisms].
    *
    * The default value of {decimals} is 18. To change this, you should override
    * this function so it returns a different value.
    *
    * We have followed general OpenZeppelin Contracts guidelines: functions revert
    * instead returning `false` on failure. This behavior is nonetheless
    * conventional and does not conflict with the expectations of ERC20
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 3 of 26 : IERC20Metadata.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
    pragma solidity ^0.8.0;
    import "../IERC20.sol";
    /**
    * @dev Interface for the optional metadata functions from the ERC20 standard.
    *
    * _Available since v4.1._
    */
    interface IERC20Metadata is IERC20 {
    /**
    * @dev Returns the name of the token.
    */
    function name() external view returns (string memory);
    /**
    * @dev Returns the symbol of the token.
    */
    function symbol() external view returns (string memory);
    /**
    * @dev Returns the decimals places of the token.
    */
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 4 of 26 : IERC20.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
    pragma solidity ^0.8.0;
    /**
    * @dev Interface of the ERC20 standard as defined in the EIP.
    */
    interface IERC20 {
    /**
    * @dev Emitted when `value` tokens are moved from one account (`from`) to
    * another (`to`).
    *
    * Note that `value` may be zero.
    */
    event Transfer(address indexed from, address indexed 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.
    */
    event Approval(address indexed owner, address indexed spender, uint256 value);
    /**
    * @dev Returns the amount of tokens in existence.
    */
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 5 of 26 : Context.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
    pragma solidity ^0.8.0;
    /**
    * @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.
    */
    abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
    return msg.sender;
    }
    function _msgData() internal view virtual returns (bytes calldata) {
    return msg.data;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 6 of 26 : Diamondable.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    // SPDX-License-Identifier: MIT
    pragma solidity 0.8.18;
    import { LibDiamond } from "./libraries/LibDiamond.sol";
    contract Diamondable {
    error Unauthorized(address account);
    modifier onlyDiamond() {
    LibDiamond.enforceDiamondItself();
    _;
    }
    function diamond() internal view returns (address diamond_) {
    diamond_ = LibDiamond.diamondStorage().diamondAddress;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 7 of 26 : Core.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Contracts/Libraries/Modifiers
    import { LibCore } from "../../libraries/LibCore.sol";
    import { LibUsd } from "../../libraries/LibUsd.sol";
    import { LibTokens } from "../../libraries/LibTokens.sol";
    import { LibDex } from "../../libraries/LibDex.sol";
    import { LibLST } from "../../libraries/LibLST.sol";
    import { Diamondable } from "../../Diamondable.sol";
    // Facets
    import { FakePools } from "./LaunchStrategies/FakePools.sol";
    import { Launcher } from "./Launcher.sol";
    import { Degen } from "./Degen.sol";
    // Interfaces
    import { Token } from "../../../Token.sol";
    // Third Party
    import { DynamicBufferLib } from "solady/src/utils/DynamicBufferLib.sol";
    contract Core is Diamondable {
    event TokenCreated(
    address token,
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 8 of 26 : Degen.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Contracts/Libraries/Modifiers
    import { LibUsd } from "../../libraries/LibUsd.sol";
    import { Diamondable } from "../../Diamondable.sol";
    import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
    contract Degen is Diamondable {
    struct Storage {
    mapping(address => string) pfps;
    mapping(address => uint256) xp;
    }
    function store() internal pure returns (Storage storage s) {
    bytes32 position = keccak256("diamond.degen.storage");
    assembly { s.slot := position }
    }
    event PfpSet(address degen);
    function pfp(address degen) public view returns (string memory) {
    return string.concat("data:image/webp;base64,", store().pfps[degen]);
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 9 of 26 : EqualizerLpHandler.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Contracts/Libraries/Modifiers
    import { Diamondable } from "../../../Diamondable.sol";
    // Libraries
    import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
    // Interfaces
    import { Token } from "../../../../Token.sol";
    interface IEqualV2Pair {
    function totalSupply() external view returns (uint);
    function getReserves() external view returns (uint _reserve0, uint _reserve1, uint _blockTimestampLast);
    }
    interface IEqualV3Router {
    function weth() external view returns (address);
    function pairFor(address tokenA, address tokenB, bool stable) external view returns (address pair);
    function addLiquidityETH(
    address token,
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 10 of 26 : Launcher.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Contracts/Libraries/Modifiers
    import { LibDex } from "../../libraries/LibDex.sol";
    import { LibCore } from "../../libraries/LibCore.sol";
    import { LibUtils } from "../../libraries/LibUtils.sol";
    import { LibTokens } from "../../libraries/LibTokens.sol";
    import { Diamondable } from "../../Diamondable.sol";
    // Facets
    import { FakePools } from "./LaunchStrategies/FakePools.sol";
    contract Launcher is Diamondable {
    function launch(address token, LibTokens.TokenInfo calldata tokenInfo) public onlyDiamond returns (address pair, uint256 eth, uint256 tokens) {
    if (tokenInfo.strategy == LibTokens.LaunchStrategy.FakeLiquidity) {
    uint256 fakeEth;
    (eth, tokens, fakeEth) = FakePools(address(this)).fakepool_close(token);
    eth = deductLaunchFee(eth);
    LibDex.addLiquidty(tokenInfo.dex, token, eth + fakeEth, tokens);
    LibDex.decreaseLiquidity(tokenInfo.dex, token, fakeEth);
    } else {
    revert("invalid strategy");
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 11 of 26 : IChainlinkAggregatorV3.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    interface IChainlinkAggregatorV3 {
    function latestRoundData()
    external
    view
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 12 of 26 : IDiamondCut.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity 0.8.18;
    /******************************************************************************\
    * Author: Nick Mudge <nick@perfectabstractions.com> (https://twitter.com/mudgen)
    * EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
    /******************************************************************************/
    interface IDiamondCut {
    enum FacetCutAction {
    Add,
    Replace,
    Remove
    }
    // Add=0, Replace=1, Remove=2
    struct FacetCut {
    address facetAddress;
    FacetCutAction action;
    bytes4[] functionSelectors;
    }
    /// @notice Add/replace/remove any number of functions and optionally execute
    /// a function with delegatecall
    /// @param _diamondCut Contains the facet addresses and function selectors
    /// @param _init The address of the contract or facet to execute _calldata
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 13 of 26 : LibCore.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    import { LibUtils } from "./LibUtils.sol";
    library LibCore {
    bytes32 constant STORAGE_POSITION = keccak256("diamond.core.storage");
    struct Storage {
    address proceedsReceiver;
    uint256 creationPrice;
    uint16 tradeFee;
    uint16 launchFee;
    uint256 tokenSupply;
    }
    function store() internal pure returns (Storage storage s) {
    bytes32 position = STORAGE_POSITION;
    assembly { s.slot := position }
    }
    function gatherProceeds(uint256 amount) internal {
    (bool sent,) = store().proceedsReceiver.call{value: amount}("");
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 14 of 26 : LibDex.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Facets
    import { EqualizerLpHandler } from "../facets/degen/dexes/EqualizerLpHandler.sol";
    library LibDex {
    enum Dex {
    Shadow, // https://github.com/code-423n4/2024-10-ramses-exchange/blob/main/contracts/CL/periphery/NonfungiblePositionManager.sol, https
                ://github.com/code-423n4/2024-10-ramses-exchange/blob/main/contracts/CL/core/RamsesV3Factory.sol
    Equalizer // https://ftmscan.com/address/0x2B52294425a9a229322228de659eDE9D146D7c2f#writeContract, https://ftmscan.com/address
                /0xE6dA85feb3B4E0d6AEd95c41a125fba859bB9d24#writeContract
    }
    function getPair(Dex dex, address token) internal view returns (address pair) {
    if (dex == Dex.Shadow) {
    // TODO
    pair = address(0);
    } else if (dex == Dex.Equalizer) {
    pair = EqualizerLpHandler(address(this)).equal_pairFor(token);
    }
    }
    function addLiquidty(Dex dex, address token, uint256 ethAmount, uint256 tokenAmount) internal {
    if (dex == Dex.Shadow) {
    // TODO
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 15 of 26 : LibDiamond.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity 0.8.18;
    /******************************************************************************\
    * Author: Nick Mudge <nick@perfectabstractions.com> (https://twitter.com/mudgen)
    * EIP-2535 Diamonds: https://eips.ethereum.org/EIPS/eip-2535
    /******************************************************************************/
    import {IDiamondCut} from "../interfaces/IDiamondCut.sol";
    // Remember to add the loupe functions from DiamondLoupeFacet to the diamond.
    // The loupe functions are required by the EIP2535 Diamonds standard
    error InitializationFunctionReverted(
    address _initializationContractAddress,
    bytes _calldata
    );
    library LibDiamond {
    bytes32 constant DIAMOND_STORAGE_POSITION =
    keccak256("diamond.standard.diamond.storage");
    struct FacetAddressAndPosition {
    address facetAddress;
    uint96 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 16 of 26 : LibFakePools.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    library LibFakePools {
    bytes32 constant STORAGE_POSITION = keccak256("diamond.fakepools.storage");
    struct FakePool {
    address token;
    uint256 ethReserve;
    uint256 tokenReserve;
    }
    struct Storage {
    uint256 fakeUsd;
    uint256 usdMcapThreshold;
    mapping(address => FakePool) pools;
    }
    function store() internal pure returns (Storage storage s) {
    bytes32 position = STORAGE_POSITION;
    assembly { s.slot := position }
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 17 of 26 : LibLST.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    library LibLST {
    bytes32 constant STORAGE_POSITION = keccak256("diamond.lst.storage");
    struct Storage {
    uint256 staked;
    }
    function store() internal pure returns (Storage storage s) {
    bytes32 position = STORAGE_POSITION;
    assembly { s.slot := position }
    }
    function addLiquidity(uint256 ethAmount) internal {
    store().staked += ethAmount;
    }
    function removeLiquidity(uint256 ethAmount) internal {
    store().staked -= ethAmount;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 18 of 26 : LibTokens.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    import { LibDex } from "./LibDex.sol";
    library LibTokens {
    bytes32 constant STORAGE_POSITION = keccak256("diamond.tokens.storage");
    enum LaunchStrategy {
    FakeLiquidity
    }
    struct TokenInfo {
    address creator;
    LaunchStrategy strategy;
    LibDex.Dex dex;
    }
    struct Storage {
    mapping(address => TokenInfo) tokens;
    }
    function store() internal pure returns (Storage storage s) {
    bytes32 position = STORAGE_POSITION;
    assembly { s.slot := position }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 19 of 26 : LibUsd.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    import { IChainlinkAggregatorV3 } from "../interfaces/IChainlinkAggregatorV3.sol";
    import { FixedPointMathLib } from "solady/src/utils/FixedPointMathLib.sol";
    library LibUsd {
    bytes32 constant STORAGE_POSITION = keccak256("diamond.usd.storage");
    struct ChainlinkOracle {
    address priceFeed;
    uint256 heartBeat;
    }
    struct Storage {
    ChainlinkOracle usdOracle;
    }
    function store() internal pure returns (Storage storage s) {
    bytes32 position = STORAGE_POSITION;
    assembly { s.slot := position }
    }
    function ethToUsd(uint256 ethAmount) internal view returns (uint256) {
    return FixedPointMathLib.mulWad(ethAmount, getPrice());
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 20 of 26 : LibUtils.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    library LibUtils {
    function calculatePercentage(uint16 fee, uint256 amount) internal pure returns (uint256) {
    return amount * fee / 1000;
    }
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 21 of 26 : Token.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    // SPDX-License-Identifier: UNKNOWN
    pragma solidity 0.8.18;
    // Contracts/Libraries/Modifiers
    import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
    import { Base64 } from "solady/src/utils/Base64.sol";
    import { LibString } from "solady/src/utils/LibString.sol";
    contract Token is ERC20 {
    address internal protocol;
    bool internal locked = true;
    address internal creator;
    string internal descripiton;
    bytes internal image;
    string[] internal links;
    constructor(address _creator, string memory name, string memory symbol, string memory _desc, bytes memory _image, string[] memory _links, uint256
            _supply, address _protocol) ERC20(name, symbol) {
    protocol = _protocol;
    creator = _creator;
    descripiton = _desc;
    image = _image;
    links = _links;
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 22 of 26 : Base64.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.4;
    /// @notice Library to encode strings in Base64.
    /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Base64.sol)
    /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Base64.sol)
    /// @author Modified from (https://github.com/Brechtpd/base64/blob/main/base64.sol) by Brecht Devos - <brecht@loopring.org>.
    library Base64 {
    /// @dev Encodes `data` using the base64 encoding described in RFC 4648.
    /// See: https://datatracker.ietf.org/doc/html/rfc4648
    /// @param fileSafe Whether to replace '+' with '-' and '/' with '_'.
    /// @param noPadding Whether to strip away the padding.
    function encode(bytes memory data, bool fileSafe, bool noPadding)
    internal
    pure
    returns (string memory result)
    {
    /// @solidity memory-safe-assembly
    assembly {
    let dataLength := mload(data)
    if dataLength {
    // Multiply by 4/3 rounded up.
    // The `shl(2, ...)` is equivalent to multiplying by 4.
    let encodedLength := shl(2, div(add(dataLength, 2), 3))
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 23 of 26 : DynamicBufferLib.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.4;
    /// @notice Library for buffers with automatic capacity resizing.
    /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/DynamicBufferLib.sol)
    /// @author Modified from cozyco (https://github.com/samkingco/cozyco/blob/main/contracts/utils/DynamicBuffer.sol)
    library DynamicBufferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* STRUCTS */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Type to represent a dynamic buffer in memory.
    /// You can directly assign to `data`, and the `p` function will
    /// take care of the memory allocation.
    struct DynamicBuffer {
    bytes data;
    }
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* OPERATIONS */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    // Some of these functions returns the same buffer for function chaining.
    // `e.g. `buffer.p("1").p("2")`.
    /// @dev Shorthand for `buffer.data.length`.
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 24 of 26 : FixedPointMathLib.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.4;
    /// @notice Arithmetic library with operations for fixed-point numbers.
    /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/FixedPointMathLib.sol)
    /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
    library FixedPointMathLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* CUSTOM ERRORS */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The operation failed, as the output exceeds the maximum value of uint256.
    error ExpOverflow();
    /// @dev The operation failed, as the output exceeds the maximum value of uint256.
    error FactorialOverflow();
    /// @dev The operation failed, due to an overflow.
    error RPowOverflow();
    /// @dev The mantissa is too big to fit.
    error MantissaOverflow();
    /// @dev The operation failed, due to an multiplication overflow.
    error MulWadFailed();
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 25 of 26 : LibBytes.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.4;
    /// @notice Library for byte related operations.
    /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBytes.sol)
    library LibBytes {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* STRUCTS */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Goated bytes storage struct that totally MOGs, no cap, fr.
    /// Uses less gas and bytecode than Solidity's native bytes storage. It's meta af.
    /// Packs length with the first 31 bytes if <255 bytes, so it’s mad tight.
    struct BytesStorage {
    bytes32 _spacer;
    }
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* CONSTANTS */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The constant returned when the `search` is not found in the bytes.
    uint256 internal constant NOT_FOUND = type(uint256).max;
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* BYTE STORAGE OPERATIONS */
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    File 26 of 26 : LibString.sol
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.4;
    import {LibBytes} from "./LibBytes.sol";
    /// @notice Library for converting numbers into strings and other string operations.
    /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
    /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
    ///
    /// @dev Note:
    /// For performance and bytecode compactness, most of the string operations are restricted to
    /// byte strings (7-bit ASCII), except where otherwise specified.
    /// Usage of byte string operations on charsets with runes spanning two or more bytes
    /// can lead to undefined behavior.
    library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /* STRUCTS */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Goated string storage struct that totally MOGs, no cap, fr.
    /// Uses less gas and bytecode than Solidity's native string storage. It's meta af.
    /// Packs length with the first 31 bytes if <255 bytes, so it’s mad tight.
    struct StringStorage {
    bytes32 _spacer;
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Settings
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    {
    "optimizer": {
    "enabled": true,
    "runs": 1337
    },
    "viaIR": true,
    "outputSelection": {
    "*": {
    "*": [
    "evm.bytecode",
    "evm.deployedBytecode",
    "devdoc",
    "userdoc",
    "metadata",
    "abi"
    ]
    }
    },
    "libraries": {}
    }
    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

    Contract Security Audit

    Contract ABI

    [{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"Unauthorized","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"fakepool_buy","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"fakepool_close","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"supply","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"fakepool_create","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bool","name":"ethOut","type":"bool"}],"name":"fakepool_quote","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"fakepool_sell","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"}]

    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

    Deployed Bytecode

    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

    Block Age Transaction Gas Used Reward
    view all blocks produced

    Block Age Uncle Number Difficulty Gas Used Reward
    View All Uncles
    Loading...
    Loading
    Loading...
    Loading

    Validator Index Block Age Amount
    View All Withdrawals

    Transaction Hash Block Age Value Eth2 PubKey Valid
    View All Deposits

    A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.