ETH Price: $2,743.53 (+3.08%)

Contract

0xdAA74081C7D301d09CD4Fb4a734648921121a32B
 

Overview

ETH Balance

0 ETH

ETH Value

$0.00

Token Holdings

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
New Tranche154936992025-02-17 13:00:1310 hrs ago1739797213IN
0xdAA74081...21121a32B
0 ETH0.000000290.00243707
New Tranche154504992025-02-16 13:00:1334 hrs ago1739710813IN
0xdAA74081...21121a32B
0 ETH0.000000970.00803394
New Tranche154073012025-02-15 13:00:172 days ago1739624417IN
0xdAA74081...21121a32B
0 ETH0.000000380.00319245
New Tranche153641002025-02-14 13:00:153 days ago1739538015IN
0xdAA74081...21121a32B
0 ETH0.000000880.00734508
New Tranche153209012025-02-13 13:00:174 days ago1739451617IN
0xdAA74081...21121a32B
0 ETH0.000000340.00288975
New Tranche152777002025-02-12 13:00:155 days ago1739365215IN
0xdAA74081...21121a32B
0 ETH0.000000660.0055141
New Tranche152345002025-02-11 13:00:156 days ago1739278815IN
0xdAA74081...21121a32B
0 ETH0.000001160.00962524
New Tranche151913002025-02-10 13:00:157 days ago1739192415IN
0xdAA74081...21121a32B
0 ETH0.000000460.00387178
New Tranche151481002025-02-09 13:00:158 days ago1739106015IN
0xdAA74081...21121a32B
0 ETH0.000000270.00230281
New Tranche151049002025-02-08 13:00:159 days ago1739019615IN
0xdAA74081...21121a32B
0 ETH0.000000370.00312194
Claims150941432025-02-08 7:01:419 days ago1738998101IN
0xdAA74081...21121a32B
0 ETH0.000000140.00170037
New Tranche150616992025-02-07 13:00:1310 days ago1738933213IN
0xdAA74081...21121a32B
0 ETH0.000000430.00361333
New Tranche150185002025-02-06 13:00:1511 days ago1738846815IN
0xdAA74081...21121a32B
0 ETH0.000000690.0057463
New Tranche149752992025-02-05 13:00:1312 days ago1738760413IN
0xdAA74081...21121a32B
0 ETH0.00000070.00579033
New Tranche149321002025-02-04 13:00:1513 days ago1738674015IN
0xdAA74081...21121a32B
0 ETH0.000000460.00383266
New Tranche148889012025-02-03 13:00:1714 days ago1738587617IN
0xdAA74081...21121a32B
0 ETH0.000000520.0043575
New Tranche148456992025-02-02 13:00:1315 days ago1738501213IN
0xdAA74081...21121a32B
0 ETH0.000000310.00260457
New Tranche148025002025-02-01 13:00:1516 days ago1738414815IN
0xdAA74081...21121a32B
0 ETH0.000000290.00246057
New Tranche147592992025-01-31 13:00:1317 days ago1738328413IN
0xdAA74081...21121a32B
0 ETH0.000000310.00263621
New Tranche147161002025-01-30 13:00:1518 days ago1738242015IN
0xdAA74081...21121a32B
0 ETH0.000000320.00272499
New Tranche146729002025-01-29 13:00:1519 days ago1738155615IN
0xdAA74081...21121a32B
0 ETH0.000000290.00244296
New Tranche146296992025-01-28 13:00:1320 days ago1738069213IN
0xdAA74081...21121a32B
0 ETH0.000000260.00217382
New Tranche145864992025-01-27 13:00:1321 days ago1737982813IN
0xdAA74081...21121a32B
0 ETH0.000000390.00325243
Claims145569492025-01-26 20:35:1322 days ago1737923713IN
0xdAA74081...21121a32B
0 ETH0.00000010.00103731
New Tranche145433002025-01-26 13:00:1522 days ago1737896415IN
0xdAA74081...21121a32B
0 ETH0.000000270.00228927
View all transactions

Parent Transaction Hash Block From To
View All Internal Transactions

Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Airdropper

Compiler Version
v0.8.21+commit.d9974bed

Optimization Enabled:
Yes with 200 runs

Other Settings:
paris EvmVersion
File 1 of 15 : Airdropper.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import {IFairLauncher} from "./interface/IFairLauncher.sol";
import {IAirdropper} from "./interface/IAirdropper.sol";
import {Erc20Utils, IERC20} from "../common/Erc20Utils.sol";
import {BlastAdapter} from "../BlastAdapter.sol";
import "@openzeppelin-5/contracts/utils/cryptography/MerkleProof.sol";

/**
 * @title Airdropper Contract
 * @dev Manages the claiming of airdropped tokens for multiple token launch campaigns.
 * Utilizes OpenZeppelin's Ownable for ownership management.
 */
contract Airdropper is BlastAdapter, IAirdropper {
    using Erc20Utils for IERC20;

    // Structure to store tranche details
    struct Tranche {
        uint256 total; // Total tokens allocated for the tranche
        uint256 claimed; // Total tokens claimed from the tranche
        uint256 startTime; // Start time for claiming tokens from the tranche
        bytes32 merkleRoot; // Merkle root for the tranche
    }

    // Structure to store airdrop details
    struct Airdrop {
        address fairLauncher; // Address of the FairLauncher contract
        uint256 totalAmount; // Total amount of tokens available for the airdrop
        uint256 totalReleased; // Total amount of tokens assigned to tranches
        uint256 releaseStartAt; // Start time for the release of the airdrop
        uint256 releaseEndAt; // End time for the release of the airdrop
        uint256 trancheIdx; // Index to track the current tranche, auto-incremented
    }

    address public fairLauncher; // Address of the FairLauncher contract
    address public executor; // Address authorized to execute newTranche functions.

    // Mappings to manage multiple token distributions
    mapping(address token => Airdrop) public airdrops; // Mapping of token address to Airdrop struct
    mapping(address token => mapping(uint256 trancheId => Tranche)) public tranches; // Mapping of token address to tranche ID to Tranche struct
    mapping(address token => mapping(uint256 trancheId => mapping(address user => uint256 amount))) public claimed; // Mapping of token address to tranche ID to user address to claimed amount

    /**
     * @notice Constructor to create Airdropper contract instance.
     * @param _fairLauncher Address of the FairLauncher contract.
     */
    constructor(address _fairLauncher, address _executor) {
        fairLauncher = _fairLauncher;
        executor = _executor;
    }

    /**
     * @notice Allows FairLauncher to donate tokens for airdrop.
     * @param _token Address of the token being donated.
     * @param _amount Amount of tokens to donate.
     * @param _releaseStartAt Release start time for the airdrop.
     * @param _releaseEndAt Release end time for the airdrop.
     */
    function createAirdrop(address _token, uint256 _amount, uint256 _releaseStartAt, uint256 _releaseEndAt) external override {
        if (_msgSender() != fairLauncher) revert OnlyFairLauncher();
        if (_releaseStartAt < block.timestamp || _releaseStartAt >= _releaseEndAt) revert InvalidTime();
        Airdrop storage airdrop = airdrops[_token];
        if (airdrop.totalAmount > 0) revert AlreadyCreated();

        uint256 received = IERC20(_token).safeTransferIn(_msgSender(), _amount);
        if (_amount != received) revert InvalidAmount();

        airdrop.totalAmount = _amount;
        airdrop.releaseStartAt = _releaseStartAt;
        airdrop.releaseEndAt = _releaseEndAt;
        airdrop.fairLauncher = fairLauncher;

        emit Airdropped(_token, _amount, airdrop.releaseStartAt, airdrop.releaseEndAt, fairLauncher);
    }

    /**
     * @notice Adds a new tranche for token distribution.
     * @param _token Address of the token.
     * @param _merkleRoot The merkle root for verifying claims.
     * @param _total The total amount of tokens in the tranche.
     * @param _startTime The start time for claiming tokens in the tranche.
     */
    function newTranche(address _token, uint256 _total, uint256 _startTime, bytes32 _merkleRoot) external override {
        if (_msgSender() != executor) revert OnlyExecutor();
        if (_startTime < block.timestamp) revert InvalidTime();

        Airdrop storage airdrop = airdrops[_token];
        if (!IFairLauncher(airdrop.fairLauncher).launched(_token)) revert NotStarted();

        uint256 releasable = _releasable(airdrop.totalAmount, airdrop.releaseStartAt, airdrop.releaseEndAt);
        if (_total == 0 || _total > releasable - airdrop.totalReleased) revert InvalidAmount();

        airdrop.totalReleased += _total;
        uint256 trancheId = ++airdrop.trancheIdx;
        tranches[_token][trancheId] = Tranche(_total, 0, _startTime, _merkleRoot);

        emit TrancheAdded(_token, trancheId, _total, _startTime, _merkleRoot);
    }

    /**
     * @notice Claims tokens from multiple tranches.
     * @param _token Address of the token.
     * @param _trancheIds Array of tranche IDs to claim from.
     * @param _amounts Array of amounts to claim from each tranche.
     * @param _merkleProofs Array of merkle proofs for each claim.
     */
    function claims(address _token, uint256[] calldata _trancheIds, uint256[] calldata _amounts, bytes32[][] calldata _merkleProofs) external override {
        uint256 len = _trancheIds.length;
        if (len == 0 || len != _amounts.length || len != _merkleProofs.length) revert InvalidParam();

        uint256 totalClaim;
        for (uint256 i = 0; i < len; i++) {
            totalClaim += _claim(_token, _trancheIds[i], _amounts[i], _merkleProofs[i]);
        }

        IERC20(_token).transferOut(_msgSender(), totalClaim);
    }

    function setFairLauncher(address _fairLauncher) external override onlyOwner {
        if (_fairLauncher == address(0)) revert ZeroAddress();
        fairLauncher = _fairLauncher;
    }

    function setExecutor(address _executor) external override onlyOwner {
        if (_executor == address(0)) revert ZeroAddress();
        executor = _executor;
    }

    /**
     * @notice Returns the amount of tokens that can be released for a given token.
     * @param _token Address of the token.
     * @return The releasable amount of tokens.
     */
    function getReleasable(address _token) external view override returns (uint256) {
        Airdrop memory airdrop = airdrops[_token];
        return _releasable(airdrop.totalAmount, airdrop.releaseStartAt, airdrop.releaseEndAt);
    }

    /**
     * @dev Claims tokens from a specific tranche.
     * @param _token Address of the token.
     * @param _trancheId ID of the tranche to claim from.
     * @param _amount Amount of tokens to claim.
     * @param _merkleProof Merkle proof for verifying the claim.
     * @return amount The amount of tokens claimed.
     */
    function _claim(address _token, uint256 _trancheId, uint256 _amount, bytes32[] calldata _merkleProof) internal returns (uint256 amount) {
        Tranche storage tranche = tranches[_token][_trancheId];
        if (tranche.startTime == 0 || block.timestamp < tranche.startTime) revert NotStarted();
        if (claimed[_token][_trancheId][_msgSender()] > 0) revert AlreadyClaimed();
        if (_amount > tranche.total - tranche.claimed) revert ExceedsMaximum();
        if (_amount == 0 || !_verifyMerkle(_msgSender(), tranche.merkleRoot, _amount, _merkleProof)) revert InvalidParam();

        claimed[_token][_trancheId][_msgSender()] = _amount;
        tranche.claimed += _amount;

        emit Claimed(_token, _trancheId, _msgSender(), _amount);
        return _amount;
    }

    /**
     * @dev Verifies the merkle proof for a claim.
     * @param account The address of the account claiming tokens.
     * @param root The merkle root for the tranche.
     * @param _balance The amount of tokens being claimed.
     * @param _merkleProof The merkle proof for the claim.
     * @return valid Boolean indicating whether the proof is valid.
     */
    function _verifyMerkle(address account, bytes32 root, uint256 _balance, bytes32[] calldata _merkleProof) internal pure returns (bool valid) {
        bytes32 leaf = keccak256(abi.encodePacked(account, _balance));
        return MerkleProof.verify(_merkleProof, root, leaf);
    }

    /**
     * @dev Calculates the releasable amount of tokens based on the current timestamp.
     * @param total Total amount of tokens to be released.
     * @param startTime Start time of the release period.
     * @param endTime End time of the release period.
     * @return releasable The amount of tokens that can be released.
     */
    function _releasable(uint256 total, uint256 startTime, uint256 endTime) internal view returns (uint256 releasable) {
        if (block.timestamp >= endTime) {
            return total;
        } else {
            return ((block.timestamp - startTime) * total) / (endTime - startTime);
        }
    }
}

File 2 of 15 : Ownable.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

File 3 of 15 : IERC20Permit.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

File 4 of 15 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

File 5 of 15 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

File 6 of 15 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

File 7 of 15 : Context.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

File 8 of 15 : MerkleProof.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

File 9 of 15 : IBlast.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.21;

interface IBlast {
    enum YieldMode {
        AUTOMATIC,
        VOID,
        CLAIMABLE
    }

    enum GasMode {
        VOID,
        CLAIMABLE
    }

    // configure
    function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external;
    function configure(YieldMode _yield, GasMode gasMode, address governor) external;

    // base configuration options
    function configureClaimableYield() external;
    function configureClaimableYieldOnBehalf(address contractAddress) external;
    function configureAutomaticYield() external;
    function configureAutomaticYieldOnBehalf(address contractAddress) external;
    function configureVoidYield() external;
    function configureVoidYieldOnBehalf(address contractAddress) external;
    function configureClaimableGas() external;
    function configureClaimableGasOnBehalf(address contractAddress) external;
    function configureVoidGas() external;
    function configureVoidGasOnBehalf(address contractAddress) external;
    function configureGovernor(address _governor) external;
    function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external;

    // claim yield
    function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256);
    function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256);

    // claim gas
    function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256);
    function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256);
    function claimGas(address contractAddress, address recipientOfGas, uint256 gasToClaim, uint256 gasSecondsToConsume) external returns (uint256);

    // read functions
    function readClaimableYield(address contractAddress) external view returns (uint256);
    function readYieldConfiguration(address contractAddress) external view returns (uint8);
    function readGasParams(address contractAddress) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode);
}

File 10 of 15 : IBlastPoints.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.21;

interface IBlastPoints {
    function configurePointsOperator(address operator) external;
}

File 11 of 15 : BlastAdapter.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import {Ownable} from "@openzeppelin-5/contracts/access/Ownable.sol";
import {IBlast} from "./blast/IBlast.sol";
import {IBlastPoints} from "./blast/IBlastPoints.sol";

contract BlastAdapter is Ownable {
    constructor() Ownable(_msgSender()) {}

    function enableClaimable(address gov) public onlyOwner {
        IBlast(0x4300000000000000000000000000000000000002).configure(IBlast.YieldMode.CLAIMABLE, IBlast.GasMode.CLAIMABLE, gov);
        IBlastPoints(0x2536FE9ab3F511540F2f9e2eC2A805005C3Dd800).configurePointsOperator(gov);
    }
}

File 12 of 15 : Erc20Utils.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

import {SafeERC20, IERC20} from "@openzeppelin-5/contracts/token/ERC20/utils/SafeERC20.sol";
import {IWETH} from "../common/IWETH.sol";

library Erc20Utils {
    error ETHTransferFailed();
    using SafeERC20 for IERC20;

    function balanceOfThis(IERC20 token) internal view returns (uint256) {
        return token.balanceOf(address(this));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        token.forceApprove(spender, value);
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal returns (uint256) {
        uint256 balance = balanceOfThis(token);
        token.safeTransferFrom(from, to, amount);
        return balanceOfThis(token) - balance;
    }

    function safeTransferIn(IERC20 token, address from, uint256 amount) internal returns (uint256) {
        uint256 balance = balanceOfThis(token);
        token.safeTransferFrom(from, address(this), amount);
        return balanceOfThis(token) - balance;
    }

    function transferOut(IERC20 token, address to, uint256 amount) internal {
        token.safeTransfer(to, amount);
    }

    function uniTransferOut(IERC20 token, address to, uint256 amount, address weth) internal {
        if (address(token) == weth) {
            IWETH(weth).withdraw(amount);
            (bool success, ) = to.call{value: amount}("");
            if (!success) revert ETHTransferFailed();
        } else {
            transferOut(token, to, amount);
        }
    }
}

File 13 of 15 : IWETH.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

interface IWETH {
    function deposit() external payable;

    function withdraw(uint256) external;
}

File 14 of 15 : IAirdropper.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

interface IAirdropper {

    // Error declarations
    error ZeroAddress();
    error InvalidAmount();
    error InvalidTime();
    error InvalidParam();
    error OnlyExecutor();
    error OnlyFairLauncher();
    error NotStarted();
    error AlreadyCreated();
    error AlreadyClaimed();
    error ExceedsMaximum();

    // Events
    event Airdropped(address indexed token, uint256 amount, uint256 releaseStartAt, uint256 releaseEndAt, address fairLauncher);
    event TrancheAdded(address indexed token, uint256 trancheId, uint256 total, uint256 startTime, bytes32 merkleRoot);
    event Claimed(address indexed token, uint256 trancheId, address user, uint256 amount);

    function createAirdrop(address _token, uint256 _amount, uint256 _releaseStartAt, uint256 _releaseEndAt) external;
    function newTranche(address _token, uint256 _total, uint256 _startTime, bytes32 _merkleRoot) external;
    function claims(address _token, uint256[] calldata _trancheIds, uint256[] calldata _amounts, bytes32[][] calldata _merkleProofs) external;
    function setFairLauncher(address _fairLauncher) external;
    function setExecutor(address _fairLauncher) external;
    function getReleasable(address _token) external view returns (uint256);

}

File 15 of 15 : IFairLauncher.sol
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.21;

interface IFairLauncher {

    error ZeroAddress();
    error ZeroAmount();
    error InvalidETH();
    error InvalidTokenCfg();
    error InvalidTokenomicsCfg();
    error InvalidTimeCfg();
    error InvalidContributionCfg();
    error InvalidLaunchCfg();
    error InvalidParam();
    error InvalidAddress();
    error InvalidInviter();
    error InvalidSignature();
    error NotStarted();
    error NotLaunched();
    error NotEnded();
    error NotEnough();
    error Ended();
    error ExceedsMaximum();
    error AlreadyLaunched();
    error AlreadyClaimed();
    error AlreadyRefund();
    error AlreadyReserved();
    error UnsupportedDex();
    error OnlyExecutor();
    error Suspend();

    struct TokenCfg {
        uint256 totalSupply;
        string name;
        string symbol;
    }

    struct PresaleCfg {
        uint256 startTime; //  startTime The start time of the presale.
        uint256 endTime; // The end time of the presale.
        uint256 personalCapMin; // The minimum ETH required to participate in the presale for a user.
        uint256 personalCapMax; // The maximum ETH allowed to participate in the presale for a user.
        uint256 softCap; // The minimum ETH required to trigger the launch.
        uint256 hardCap; // The maximum ETH allowed to trigger the launch.
        uint256 overfundedDiscount; // Discount for overfunded contributions (in percentage, e.g., 8000 means 80%).
    }

    struct TokenomicsCfg {
        uint256 amtForLP; // The amount of tokens allocated for the liquidity pool.
        uint256 amtForPresale; // The amount of tokens allocated for the presale.
        uint256 amtForAirdrop; // The amount of tokens allocated for the airdrop.
        uint256 amtForFreeClaim; // The amount of tokens allocated for free claims.
        uint256 airdropDuration; // The duration for the airdrop period.
        uint256 freeClaimPerUser; // The amount of tokens each user can claim for free.
        address lpRecipient; // The address where liquidity tokens are sent.
    }

    struct FeesCfg {
        address payable feeRecipient; // The address where protocol fees are sent.
        uint256 createFees; // The ETH fees for creating a new token launch.
        uint256 launchProtocolFees; // The protocol fee percentage (e.g., 500 for 5%).
        uint256 directInviteFees; // The ETH reward percentage for direct invites (e.g., 1000 for 10%).
        uint256 secondTierInviteFees; // The ETH reward percentage for second-tier invites (e.g., 1000 for 10%).
    }

    struct SignCfg {
        address issuerAddress; // The address authorized to issue signatures.
        uint256 validDuration; // The time duration in seconds for which a signature remains valid.
    }

    struct OLESwapCfg {
        address ole; // The address of the OLE token.
        address dexRouter; // The address of the DEX router for swapping.
    }

    struct SuspendCfg {
        bool all; // A flag to suspend all operations.
        bool presale; // A flag to suspend presale operations.
        bool refund; // A flag to suspend refund operations.
        bool reserve; // A flag to suspend reserve operations.
        bool claim; // A flag to suspend claim operations.
    }

    struct ClaimableAmt {
        uint256 presaleClaim; // Amount of tokens claimable from the presale.
        uint256 freeClaim; // Amount of tokens claimable as free claim.
        uint256 oleClaim; // Amount of OLE tokens claimable.
        uint256 overfundedRefund; // Amount of ETH refundable due to overfunded.
    }

    // Events for tracking contract activities
    event LaunchCreated(
        address token,
        uint256 spaceIdx,
        address creator,
        uint256 totalSupply,
        string name,
        string symbol,
        PresaleCfg presaleCfg,
        TokenomicsCfg tokenomicsCfg,
        uint256 createOLEFees
    );
    event Participated(address indexed token, address user, address inviter, uint256 amount, uint256 share, uint256 directFees, uint256 secondTierFees);
    event Refunded(address indexed token, address user, uint256 amount);
    event FreeClaimReserved(address indexed token, address user, uint256 amount);
    event Claimed(address indexed token, address user, uint256 presale, uint256 freeClaim, uint256 oleReward, uint256 overfundedRefund);
    event Launched(address indexed token, address lpTokenAddr, uint256 liquidity, uint256 tokenForLp, uint256 ethForLp, uint256 ethForProtocolFee, uint256 oleReward);

    function newFairLaunch(TokenCfg calldata _tokenCfg, PresaleCfg calldata _presaleCfg, TokenomicsCfg calldata _tokenAssignCfg, uint256 _minBoughtOle) external payable;
    function participate(uint256 _timestamp, bytes calldata _signature, address inviter, address _token) external payable;
    function refundForLaunchFail(uint256 _timestamp, bytes calldata _signature, address _token) external;
    function reserveFreeClaim(uint256 _timestamp, bytes calldata _signature, address _token) external;
    function claims(uint256 _timestamp, bytes calldata _signature, address _token) external;
    function launch(address _token, address _dexRouter, uint256 _minBoughtOle) external;

    /*** Admin Functions ***/
    function setFeesCfg(FeesCfg calldata _cfg) external;
    function setOLESwapCfg(OLESwapCfg calldata _cfg) external;
    function setSignConf(SignCfg calldata _cfg) external;
    function setSuspendCfg(SuspendCfg calldata _cfg) external;
    function setGasOperator(address _gasOperator) external;
    function setExecutor(address _executor) external;
    function setSpaceShare(address _spaceShare) external;
    function setAirdropper(address _airdropper) external;
    function setSupportedDexRouter(address _router, bool _support) external;

    /*** View Functions ***/
    function getClaimable(address _token, address _user) external view returns (ClaimableAmt memory);
    function launched(address _token) external view returns (bool);
    function executor() external view returns (address);

}

Settings
{
  "evmVersion": "paris",
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_fairLauncher","type":"address"},{"internalType":"address","name":"_executor","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AlreadyClaimed","type":"error"},{"inputs":[],"name":"AlreadyCreated","type":"error"},{"inputs":[],"name":"ExceedsMaximum","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidParam","type":"error"},{"inputs":[],"name":"InvalidTime","type":"error"},{"inputs":[],"name":"NotStarted","type":"error"},{"inputs":[],"name":"OnlyExecutor","type":"error"},{"inputs":[],"name":"OnlyFairLauncher","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"releaseStartAt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"releaseEndAt","type":"uint256"},{"indexed":false,"internalType":"address","name":"fairLauncher","type":"address"}],"name":"Airdropped","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"trancheId","type":"uint256"},{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"trancheId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"total","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"startTime","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"TrancheAdded","type":"event"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"airdrops","outputs":[{"internalType":"address","name":"fairLauncher","type":"address"},{"internalType":"uint256","name":"totalAmount","type":"uint256"},{"internalType":"uint256","name":"totalReleased","type":"uint256"},{"internalType":"uint256","name":"releaseStartAt","type":"uint256"},{"internalType":"uint256","name":"releaseEndAt","type":"uint256"},{"internalType":"uint256","name":"trancheIdx","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"trancheId","type":"uint256"},{"internalType":"address","name":"user","type":"address"}],"name":"claimed","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256[]","name":"_trancheIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"bytes32[][]","name":"_merkleProofs","type":"bytes32[][]"}],"name":"claims","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_releaseStartAt","type":"uint256"},{"internalType":"uint256","name":"_releaseEndAt","type":"uint256"}],"name":"createAirdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"gov","type":"address"}],"name":"enableClaimable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"executor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fairLauncher","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"getReleasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_total","type":"uint256"},{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"newTranche","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_executor","type":"address"}],"name":"setExecutor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_fairLauncher","type":"address"}],"name":"setFairLauncher","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"trancheId","type":"uint256"}],"name":"tranches","outputs":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"claimed","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000007f6b14990e716342d1975f18bf3b7d89ed8d6a7f000000000000000000000000cd92489bd7ef2b199f79ff3046742e4dcd00793c

-----Decoded View---------------
Arg [0] : _fairLauncher (address): 0x7F6B14990e716342d1975f18Bf3b7d89ed8D6A7F
Arg [1] : _executor (address): 0xcd92489Bd7ef2B199F79Ff3046742e4DCD00793C

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000007f6b14990e716342d1975f18bf3b7d89ed8d6a7f
Arg [1] : 000000000000000000000000cd92489bd7ef2b199f79ff3046742e4dcd00793c


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

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

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]

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.