Launch A Token

Launch A Token

newTokenV2

To Launch a new token, you send a transaction to call the newTokenV2 method:

// solidity interface 

/// @notice Create a new token (V2) with flexible parameters
/// @param params The parameters for the new token
/// @return token The address of the created token
function newTokenV2(NewTokenV2Params calldata params) external payable returns (address token); 

/// @notice Create a new token (V4) with DEX ID and LP fee profile support
/// @param params The parameters for the new token including DEX ID and LP fee profile
/// @return token The address of the created token
/// @dev Similar to newTokenV3 but with DEX ID and LP fee profile support. Allows specifying preferred DEX and fee tier
function newTokenV4(NewTokenV4Params calldata params) external payable returns (address token);


/// @notice Create a new token (V5) with tax V2 support
/// @param params The parameters for the new token including advanced tax features
/// @return token The address of the created token
/// @dev Similar to newTokenV4 but with support for FlapTaxTokenV2 when taxRate > 0.
///      When taxRate is 0, behaves like newTokenV4 (uses regular token or FlapTaxToken).
///      When taxRate > 0, creates a FlapTaxTokenV2 with advanced tax distribution features.
function newTokenV5(NewTokenV5Params calldata params) external payable returns (address token);

/// @notice Parameters for creating a new token (V2)
struct NewTokenV2Params {
    /// The name of the token
    string name;
    /// The symbol of the token
    string symbol;
    /// The ipfs cid of the metadata 
    string meta;
    /// The DEX supply threshold type
    DexThreshType dexThresh;
    /// The salt for deterministic deployment
    bytes32 salt;
    /// The tax rate in basis points (if non-zero, this is a tax token)
    uint16 taxRate;
    /// The migrator type (see MigratorType enum)
    MigratorType migratorType;
    /// The quote token address (native gas token if zero address)
    address quoteToken;
    /// The initial quote token amount to spend for buying
    uint256 quoteAmt;
    /// The beneficiary address for the token
    /// For rev share tokens, this is the address that can claim the LP fees
    /// For tax tokens, this is the address that receives the tax fees
    address beneficiary;
    /// The optional permit data for the quote token
    bytes permitData;
}



/// @notice Parameters for creating a new token (V4) with DEX ID and LP fee profile support
struct NewTokenV4Params {
    /// The name of the token
    string name;
    /// The symbol of the token
    string symbol;
    /// The metadata URI of the token
    string meta;
    /// The DEX supply threshold type
    DexThreshType dexThresh;
    /// The salt for deterministic deployment
    bytes32 salt;
    /// The tax rate in basis points (if non-zero, this is a tax token)
    uint16 taxRate;
    /// The migrator type (see MigratorType enum)
    MigratorType migratorType;
    /// The quote token address (native gas token if zero address)
    address quoteToken;
    /// The initial quote token amount to spend for buying
    uint256 quoteAmt;
    /// The beneficiary address for the token
    /// For rev share tokens, this is the address that can claim the LP fees
    /// For tax tokens, this is the address that receives the tax fees
    address beneficiary;
    /// The optional permit data for the quote token
    bytes permitData;
    /// @notice The ID of the extension to be used for the new token if not zero
    bytes32 extensionID;
    /// @notice Additional extension specific data to be passed to the extension's `onTokenCreation` method, check the extension's documentation for details on the expected format and content.
    bytes extensionData;
    /// @notice The preferred DEX ID for the token
    DEXId dexId;
    /// @notice The preferred V3 LP fee profile for the token
    V3LPFeeProfile lpFeeProfile;
}



/// @notice Parameters for creating a new token (V5) with tax V2 support
struct NewTokenV5Params {
    /// The name of the token
    string name;
    /// The symbol of the token
    string symbol;
    /// The metadata URI of the token
    string meta;
    /// The DEX supply threshold type
    DexThreshType dexThresh;
    /// The salt for deterministic deployment
    bytes32 salt;
    /// The tax rate in basis points (if non-zero, this is a tax token)
    uint16 taxRate;
    /// The migrator type (see MigratorType enum)
    MigratorType migratorType;
    /// The quote token address (native gas token if zero address)
    address quoteToken;
    /// The initial quote token amount to spend for buying
    uint256 quoteAmt;
    /// The beneficiary address for the token
    /// For rev share tokens, this is the address that can claim the LP fees
    /// For tax tokens, this is the address that receives the tax fees
    address beneficiary;
    /// The optional permit data for the quote token
    bytes permitData;
    /// @notice The ID of the extension to be used for the new token if not zero
    bytes32 extensionID;
    /// @notice Additional extension specific data to be passed to the extension's `onTokenCreation` method, check the extension's documentation for details on the expected format and content.
    bytes extensionData;
    /// @notice The preferred DEX ID for the token
    DEXId dexId;
    /// @notice The preferred V3 LP fee profile for the token
    V3LPFeeProfile lpFeeProfile;
    // New V5 tax-specific fields (only used when taxRate > 0)
    /// Tax duration in seconds (max: 100 years)
    uint64 taxDuration;
    /// Anti-farmer duration in seconds (max: 1 year)
    uint64 antiFarmerDuration;
    /// Market allocation basis points (to beneficiary)
    uint16 mktBps;
    /// Deflation basis points (burned)
    uint16 deflationBps;
    /// Dividend basis points (to dividend contract)
    uint16 dividendBps;
    /// Liquidity provision basis points (LP to dead address)
    uint16 lpBps;
    /// Minimum balance for dividend eligibility (min: 10K ether, required when dividendBps > 0)
    uint256 minimumShareBalance;
}

/// @notice the V3 LP fee profile
/// @dev determines the LP fee tier to use when migrating tokens to Uniswap V3 or Pancake V3
enum V3LPFeeProfile {
    LP_FEE_PROFILE_STANDARD, // Standard fee tier:  0.25% on PancakeSwap, 0.3% on Uniswap
    LP_FEE_PROFILE_LOW, // Low fee tier: typically, 0.01% on PancakeSwap, 0.05% on Uniswap
    LP_FEE_PROFILE_HIGH // High fee tier (1% for exotic pairs)

}

/// @notice the DEX ID
/// @dev determines the DEX we want to migrate to
/// On BSC:
///   - only DEX0 will be enabled, which is PancakeSwap
/// On xLayer:
///   - only DEX0 will be enabled, which is PotatoSwap
/// On Monad:
///   - DEX0 is Uniswap
///   - DEX1 is PancakeSwap
///   - DEX2 is Monday
/// Note that, currently, we only support at most 3 DEXes
/// We may add more DEXes in the future if needed
enum DEXId {
    DEX0,
    DEX1,
    DEX2
}

/// @notice the migrator type
/// @dev the migrator type determines how the liquidity is added to the DEX.
/// Note: To mitigate the risk of DOS, if a V3 migrator is used but the liquidity cannot
/// be added to v3 pools, the migrator will fallback to a V2 migrator.
enum MigratorType {
    V3_MIGRATOR, // Migrate the liquidity to a Uniswap V3 like pool
    V2_MIGRATOR // Migrate the liquidity to a Uniswap V2 like pool
}

/// @dev dex threshold types
enum DexThreshType {
    TWO_THIRDS, //  66.67% supply
    FOUR_FIFTHS, // 80% supply
    HALF, // 50% supply
    _95_PERCENT, // 95% supply
    _81_PERCENT, // 81% supply
    _1_PERCENT // 1% supply => mainly for testing

}

Before sending the transaction, we should prepare the metadata:

All the metadata are stored on IPFS. You can upload your image and the meta of your token to ipfs through our API.

Check the following example to learn how to upload the image along with the meta data json to IPFS:

/// Upload the meta of the token
async function uploadTokenMeta(cfg: {
    buy: string | null;
    creator: string;
    description: string;
    sell: string | null;
    telegram: string | null;
    twitter: string | null;
    website: string | null;
    image_path: string;
}) {

    const form = new FormData();

    const MUTATION_CREATE = `
    mutation Create($file: Upload!, $meta: MetadataInput!) {
      create(file: $file, meta: $meta)
    }
    `;

    form.append(
        "operations",
        JSON.stringify({
            query: MUTATION_CREATE,
            variables: {
                file: null, meta: {
                    website: cfg.website,
                    twitter: cfg.twitter,
                    telegram: cfg.telegram,
                    description: cfg.description,
                    creator: "0x0000000000000000000000000000000000000000",
                }
            },
        })
    );

    form.append(
        "map",
        JSON.stringify({
            "0": ["variables.file"],
        })
    );

    // read local file and convert to File object, with type "image/png"
    const file = new File([fs.readFileSync(cfg.image_path)], "image.png", {
        type: "image/png",
    });
    form.append("0", file);

    const res = await axios.postForm(FlapConfig.api, form, {
        headers: {
            "Content-Type": "multipart/form-data",
        },
    });

    if (res.status !== 200) {
        throw new Error(`failed to upload the token meta: ${res.statusText}`);
    }

    console.log("token meta uploading response: ", res.data);

    // the cid is in the response data 
    const cid = res.data.data.create;

    return cid;

}

Although you may upload the image to ipfs and pin the meta on any ipfs gateway, it is recommended to upload using our API: https://funcs.flap.sh/api/upload . Our indexer may not be able to fetch your file if it is not pinned on our gateway. Besides, a lot of terminals fetch files through our gateway. We will do a CDN warmup on uploading to bootstrap the image & meta loading speed for terminals. This is crutial if you want your token to show up on terminals quickily.

After successfully uploading the image and metadata to IPFS, you will get an IPFS cid which is similar to bafkreicwlkpvrcqg4bbhyp2fnhdwbqos5ghka6gdjra3tdkgxxs74hqsze (e.g. this is the cid of the BROCCOLI token’s metadata

After that, you can get the meta json from any ipfs gateway, eg:

• https://ipfs.io/ipfs/bafkreicwlkpvrcqg4bbhyp2fnhdwbqos5ghka6gdjra3tdkgxxs74hqsze

Note the meta json has the following format:

{
  "buy": null,
  "creator": "0x9c7FC419212461342201495ffCdE6366DC32CE1c",
  "description": "CZ wanted a name for his dog that started with B and had some green in it, so he named him Broccoli. It also had a blocky sound, as in blockiichain. Could not get away from crypto, haha.",
  "image": "bafkreiccy2x5735r2q3zvcce3ub3hcgpslnn5n3dqa7fn3tgr7qgtlbjhi",
  "sell": null,
  "telegram": null,
  "twitter": null,
  "website": null
}

The image field itself is another ipfs cid for the image. Then you can get the image here: https://ipfs.io/ipfs/bafkreiccy2x5735r2q3zvcce3ub3hcgpslnn5n3dqa7fn3tgr7qgtlbjhi

Now we have the ipfs cid of the meta json, let's proceed to construct the transaction call.

The new newTokenV2 method takes a single struct (or tuple in solidity’s jargon) as its input. Let’s explain some fields of the NewTokenV2Params struct:

• meta : this is the ipfs cid you get from last section , eg, bafkreicwlkpvrcqg4bbhyp2fnhdwbqos5ghka6gdjra3tdkgxxs74hqsze

• dexThresh : This determines the threshold to migrate token to DEX. Our UI uses FOUR_FIFTHS by default, which means when 80% or more of the total supply has been sold from the bonding curve , the token will be migrated to DEX.

• taxRate : since v3.3.0, we support creating a tax token. The tax is only applied for the first year after the token being migrated to DEX. The maximum tax rate is 10%

  • Our UI only supports limited Tax Rates, but you can always use any tax rate from 0 up to 10%.

  • Since v5, the default tax duration changes from 1 year to 100 year.

• migratorType : The migrator for the token. Note, if a token has tax, it can only be migrated to a V2 pool, which means only a V2_MIGRATOR is allowed for a tax token. For other tokens, it is recommended to use a V3_MIGRATOR. With a V3_MIGRATOR we will optimize your liquidity and enable the revenue share feature for you token.

• quoteToken : The quote token you want to use. When your quote token is the native gas token (i.e ETH or BNB), leave quoteToken as the zero address. Note: only enabled quoteToken can be used.

• quoteAmt: The amount of quoteToken you want to spend to buy token on creation.

• beneficiary : If the token has not TAX and using a V3_MIGRATOR , the rev share fees can be claimed with this address; If the token has TAX, this address will receive the tax fee.

• permitData : If your quoteToken is not zero address (i.e, not native gas token ETH or BNB, but some ERC20 token). You can construct the permitData to avoid another approve TX. Check our example below to see how to construct the permitData.

• salt : The salt is mandate. All tokens created from the newTokenV2 method have a vanity ending. If the token has no tax, it has an ending of 8888 or it has an ending of 7777.

Here is an example script for generating the salt on BNB chain:

• The suffix is 8888 if your token has not tax, otherwise it is 7777

• The token impl address is :

  • 0x8B4329947e34B6d56D71A3385caC122BaDe7d78D for non tax token

  • 0x5dd913731C12aD8DF3E574859FDe45412bF4aaD9 for tax token v1

  • 0xae562c6A05b798499507c6276C6Ed796027807BA for tax token v2

• Portal address on BSC is 0xe2cE6ab80874Fa9Fa2aAE65D277Dd6B8e65C9De0

/// get vanity token address and salt 
async function findVanityTokenSalt(suffix: string, token_impl: Address, portal: Address) {
    if (suffix.length !== 4) {
        throw new Error("Suffix must be exactly 4 characters");
    }

    // predict the vanity token address based on the saltå
    const predictVanityTokenAddress = (salt: Hex): Address => {
        const bytecode = '0x3d602d80600a3d3981f3363d3d373d3d3d363d73'
            + token_impl.slice(2).toLowerCase() // remove 0x prefix
            + '5af43d82803e903d91602b57fd5bf3' as Hex;

        return getContractAddress({
            from: portal,
            salt: toBytes(salt),
            bytecode,
            opcode: "CREATE2",
        });
    }

    // Note: you don't have to use a private key as the starting seed, you can use 
    // any pseudo-random string as the starting seed. 
    // 
    // Here, we use a random private key as the starting seed
    // Then repeatedly hash the seed until we get the vanity address
    const seed = generatePrivateKey();
    let salt = keccak256(toHex(seed));
    let iterations = 0; // Track the number of iterations 

    while (!predictVanityTokenAddress(salt).endsWith(suffix)) {
        salt = keccak256(salt);
        iterations++; // Increment the iteration count
    }

    console.log(`Iterations: ${iterations}`); // Print the number of iterations

    return {
        salt,
        address: predictVanityTokenAddress(salt),
    }
}

In the above example script, we using a random private key as the seed. In reality, you can use any random number or string as your seed to find the salt.

newTokenV3, newTokenV4, and newTokenV5

In addition to newTokenV2, the portal also supports newTokenV3, newTokenV4, and newTokenV5 with additional features:

newTokenV3

Adds extension support to newTokenV2. Extensions allow custom logic to be executed during token creation and trading.

• extensionID: The unique identifier for the extension to use (bytes32(0) for no extension)

• extensionData: Additional data passed to the extension's onTokenCreation method

newTokenV4

Adds DEX preference configuration to newTokenV3:

• dexId: The preferred DEX ID for the token (DEX0, DEX1, or DEX2)

  • DEX0: Primary DEX (PancakeSwap on BSC, Uniswap on Monad, PotatoSwap on xLayer)

  • DEX1: Secondary DEX (only on Monad - PancakeSwap)

  • DEX2: Tertiary DEX (only on Monad - Monday)

• lpFeeProfile: The preferred V3 LP fee profile

  • LP_FEE_PROFILE_STANDARD: Standard fee tier (0.25% on PancakeSwap, 0.3% on Uniswap)

  • LP_FEE_PROFILE_LOW: Low fee tier (0.01% on PancakeSwap, 0.05% on Uniswap)

  • LP_FEE_PROFILE_HIGH: High fee tier (1% for exotic pairs)

newTokenV5

When using newTokenV5 for creating a tax token, if mktBps==10000 , we will create a v1 tax token, you should use Tax Token V1 impl address for computing the salt; However, if mktBps < 10000 , we will create a V2 tax token, you should use Tax Token V2 address for computing the salt. You can find the implementations address for each version of the tax tokens on different chains here: Deployed Contract Addresses

The most advanced token creation method with support for FlapTaxTokenV2 - an upgraded tax token implementation with sophisticated tax distribution features. When taxRate > 0, creates a V2 tax token with advanced capabilities; when taxRate = 0, behaves like newTokenV4.

Key Features of Tax V2 Tokens:

• Advanced Tax Distribution: Distributes tax across multiple destinations (market, deflation, dividends, liquidity)

• Configurable Tax Duration: Set custom tax duration (up to 100 years, vs. fixed 1 year in V1)

• Anti-Farmer Protection: Optional anti-farmer period to prevent immediate sell-offs after DEX migration (vs fixed 1 day in V1)

• Dividend System: Automatic dividend distribution to qualifying token holders

• Flexible Allocation: Customizable basis points for each tax destination

Additional Parameters (only applicable when taxRate > 0):

• taxDuration (uint64): Tax duration in seconds

  • Maximum: 100 years (3,153,600,000 seconds)

• antiFarmerDuration (uint64): Anti-farmer protection period in seconds

  • Maximum: 1 year (31,536,000 seconds)

  • During this period, additional restrictions may apply to prevent farming

  • Recommended to set this to at least 3 days.

• mktBps (uint16): Market allocation in basis points (to beneficiary)

  • Range: 0 to 10,000 (0% to 100%)

  • This portion goes to the beneficiary address for marketing/development

• deflationBps (uint16): Deflation allocation in basis points (burned)

  • Range: 0 to 10,000 (0% to 100%)

  • This portion is permanently burned, reducing total supply

• dividendBps (uint16): Dividend allocation in basis points (to dividend contract)

  • Range: 0 to 10,000 (0% to 100%)

  • Distributed to qualifying token holders based on their balance

  • Requires minimumShareBalance to be set if > 0

• lpBps (uint16): Liquidity provision allocation in basis points

  • Range: 0 to 10,000 (0% to 100%)

  • Added back to liquidity pool (LP tokens sent to dead address)

• minimumShareBalance (uint256): Minimum token balance for dividend eligibility

  • Minimum: 10,000 ether (10,000 * 10^18)

  • Only required when dividendBps > 0

  • Holders with balance below this threshold won't receive dividends

Important Constraints:

• The sum of all tax distribution BPS must equal 10,000 (100%):

  mktBps + deflationBps + dividendBps + lpBps = 10,000

• Tax tokens must use V2_MIGRATOR (V3 migration not supported for tax tokens)

• Maximum taxRate: 10% (1,000 basis points)

Example: Creating a Tax V2 Token

// Example: Tax token with 5% tax distributed as:
// - 40% to marketing (beneficiary)
// - 30% burned (deflationary)
// - 20% to dividends
// - 10% to liquidity

const params = {
    name: "MyTaxToken",
    symbol: "MTT",
    meta: "bafkreicwlkpvrcqg4bbhyp2fnhdwbqos5ghka6gdjra3tdkgxxs74hqsze",
    dexThresh: DexThreshType.FOUR_FIFTHS,
    salt: "0x...", // Generated vanity salt
    taxRate: 500, // 5% tax (in basis points)
    migratorType: MigratorType.V2_MIGRATOR, // Required for tax tokens
    quoteToken: "0x0000000000000000000000000000000000000000", // Native token
    quoteAmt: ethers.parseEther("0.1"),
    beneficiary: "0xYourAddress",
    permitData: "0x",
    extensionID: "0x0000000000000000000000000000000000000000000000000000000000000000",
    extensionData: "0x",
    dexId: DEXId.DEX0,
    lpFeeProfile: V3LPFeeProfile.LP_FEE_PROFILE_STANDARD,
    
    // Tax V2 specific parameters
    taxDuration: 2592000, // 30 days in seconds
    antiFarmerDuration: 86400, // 1 day anti-farmer protection
    mktBps: 4000, // 40% to marketing
    deflationBps: 3000, // 30% burned
    dividendBps: 2000, // 20% to dividends
    lpBps: 1000, // 10% to liquidity
    minimumShareBalance: ethers.parseEther("10000") // 10K minimum for dividends
};

// The sum equals 10,000: 4000 + 3000 + 2000 + 1000 = 10,000 ✓

const tx = await portal.newTokenV5(params, { value: quoteAmt });

When to Use Each Method:

• newTokenV2: Basic token creation with simple parameters

• newTokenV3: When you need extension support for custom logic

• newTokenV4: When you want to specify DEX preference and LP fee profile

• newTokenV5: When creating advanced tax tokens (V2) or need all V4 features

Events

For backward compatibility, each newly launched token will emit one or more events rather than a single event:

• TokenCreated : Every token launch will emit a TokenCreated event.

• TokenCurveSet : (optional), if a token launch does not emit this event, its curve is the first one in the CurveType enum , which is 16 ( i.e curveParameter = 16 ether )

• TokenCurveSetV2: (optional), starting from v4.7.0, this event is always emitted even when the token is using the legacy bonding curve.

• TokenDexSupplyThreshSet : (optional), if a token does not emit this event, its dex threshold is by default the first one in the DexThreshType enum, which is 6.67e8 ether.

• TokenQuoteSet : (optional), if a token does not emit this event, its quote token is the native gas token (i.e, zero address). Otherwise the quote token 's address is the quoteToken arg in the event (Currently, we support USD1 and lisUSD on BSC)

• TokenMigratorSet : (optional), if a token does not emit this event, its Migrator type is by default V3_MIGRATOR (i.e, the first one in the MigratorType enum).

• FlapTokenTaxSet : (optional), if a token does not emit this event, the tax is 0 or it is not a tax token.

• FlapTokenStaged : (optional), emitted when a token is staged but not yet created (for two-step token launch).

• TokenExtensionEnabled : (optional), emitted when an extension is enabled for a token.

• TokenDexPreferenceSet : (optional), emitted when a token's DEX preference is set (includes DEX ID and LP fee profile). For backward compatibility, if a token does not emit this event, its DEX preference is DEX0 and STANDARD fee profile.

• TokenPoolInfoUpdated : (optional), emitted when a token's pool information is updated.

/// @notice emitted when a new token is created
///
/// @param ts The timestamp of the event
/// @param creator The address of the creator
/// @param nonce The nonce of the token
/// @param token  The address of the token
/// @param name  The name of the token
/// @param symbol  The symbol of the token
/// @param meta The meta URI of the token
event TokenCreated(
  uint256 ts, address creator, uint256 nonce, address token, string name, string symbol, string meta
);

/// emitted when a token's curve is set
/// @param token The address of the token
/// @param curve The address of the curve
/// @param curveParameter The parameter of the curve
event TokenCurveSet(address token, address curve, uint256 curveParameter);

/// emitted when a token's dexSupplyThresh is set
/// @param token The address of the token
/// @param dexSupplyThresh The new dexSupplyThresh of the token
event TokenDexSupplyThreshSet(address token, uint256 dexSupplyThresh);

/// emitted when a token's implementation is set
/// @param token The address of the token
/// @param version The version of the token
event TokenVersionSet(address token, TokenVersion version);

/// @notice emitted when a token's curve parameters are set (V2)
/// @param token The address of the token
/// @param r The virtual ETH reserve parameter
/// @param h The virtual token reserve parameter
/// @param k The square of the virtual Liquidity parameter
event TokenCurveSetV2(address token, uint256 r, uint256 h, uint256 k);

/// @notice emitted when a token's quote token is set
/// @param token The address of the token
/// @param quoteToken The address of the quote token
event TokenQuoteSet(address token, address quoteToken);

/// @notice emitted when a token's migrator is set
/// @param token The address of the token
/// @param migratorType The migrator type
event TokenMigratorSet(address token, MigratorType migratorType); 

/// @notice emitted when a new tax is set for a token
/// @param token The address of the token
/// @param tax The tax value set for the token
event FlapTokenTaxSet(address token, uint256 tax);

/// @notice emitted when a token is staged (but not yet created)
/// @param ts The timestamp of the event
/// @param creator The address of the creator
/// @param token The predetermined address of the token
event FlapTokenStaged(uint256 ts, address creator, address token);

/// @notice emitted when a token's extension is enabled
/// @param token The address of the token
/// @param extensionID The extension ID
/// @param extensionAddress The address of the extension contract
/// @param version The version of the extension
event TokenExtensionEnabled(address token, bytes32 extensionID, address extensionAddress, uint8 version);

/// @notice emitted when a token's DEX preference is set
/// @param token The address of the token
/// @param dexId The preferred DEX ID for the token
/// @param lpFeeProfile The preferred V3 LP fee profile for the token
event TokenDexPreferenceSet(address token, DEXId dexId, V3LPFeeProfile lpFeeProfile);

/// @notice emitted when a token's pool info is updated
/// @param token The address of the token
/// @param poolInfo The new pool information
event TokenPoolInfoUpdated(address token, PackedDexPool poolInfo);

/// @dev curve Types
enum CurveType {
    CURVE_LEGACY_15, // r = 15
    CURVE_4, // r = 4
    CURVE_0_974, // r = 0.974
    CURVE_0_5, // r = 0.5
    CURVE_1000, // r = 1000
    CURVE_20000, // r = 20000
    CURVE_2500, // r = 2500
    CURVE_500, // r = 500
    CURVE_2, // r = 2
    CURVE_6, // r = 6
    CURVE_75, // r = 75
    CURVE_4M, // r= 4 M
    CURVE_28, // r = 28
    CURVE_21_25, // r = 21.25
    CURVE_RH_UNUSED, // r = 27.6, h = 352755468
    CURVE_RH_28D25_108002126, // r = 28.25, h = 108002126, k = 31301060059.5
    CURVE_RH_14981_108002125, // r = 14981, h = 108002125, k = 16598979834625
    CURVE_RH_TOSHI_MORPH_2ETH, // r = 0.7672, h = 107036751, k = 849318595.3672 - TOSHI/MORPH 2ETH curve
    CURVE_RH_TOSHI, // r = 6140351, h = 107036752, k = 6797594227179952 - TOSHI Curve
    CURVE_RH_BGB, // r = 767.5, h = 107036752, k = 849650707160 - BGB curve
    CURVE_RH_BNB, // r = 6.14, h = 107036752, k = 6797205657.28 - BNB Curve
    CURVE_RH_USD, // r = 3837, h = 107036752, k = 4247700017424 - USD curve
    CURVE_RH_MONAD // r = 50000, h = 107036752, k = 55351837600000 - MONAD curve
}

/// @dev Token version
/// Which token implementation is used
enum TokenVersion {
    TOKEN_LEGACY_MINT_NO_PERMIT,
    TOKEN_LEGACY_MINT_NO_PERMIT_DUPLICATE, // for historical reasons, both 0 and 1 are the same: TOKEN_LEGACY_MINT_NO_PERMIT
    TOKEN_V2_PERMIT, // 2
    TOKEN_GOPLUS, // 3
    TOKEN_TAXED, // 4: The original tax token (FlapTaxToken)
    TOKEN_TAXED_V2 // 5: The new advanced tax token (FlapTaxTokenV2)
}

/// @dev dex threshold types
enum DexThreshType {
    TWO_THIRDS, //  66.67% supply
    FOUR_FIFTHS, // 80% supply
    HALF, // 50% supply
    _95_PERCENT, // 95% supply
    _81_PERCENT, // 81% supply
    _1_PERCENT // 1% supply => mainly for testing
}

/// @notice the migrator type
/// @dev the migrator type determines how the liquidity is added to the DEX.
/// Note: To mitigate the risk of DOS, if a V3 migrator is used but the liquidity cannot
/// be added to v3 pools, the migrator will fallback to a V2 migrator.
/// A TAX token must use a V2 migrator.
enum MigratorType {
    V3_MIGRATOR, // Migrate the liquidity to a Uniswap V3 like pool
    V2_MIGRATOR // Migrate the liquidity to a Uniswap V2 like pool
}

/// @notice the V3 LP fee profile
/// @dev determines the LP fee tier to use when migrating tokens to Uniswap V3 or Pancake V3
enum V3LPFeeProfile {
    LP_FEE_PROFILE_STANDARD, // Standard fee tier:  0.25% on PancakeSwap, 0.3% on Uniswap
    LP_FEE_PROFILE_LOW, // Low fee tier: typically, 0.01% on PancakeSwap, 0.05% on Uniswap
    LP_FEE_PROFILE_HIGH // High fee tier (1% for exotic pairs)
}

/// @notice the DEX ID
/// @dev determines the DEX we want to migrate to
/// On BSC:
///   - only DEX0 will be enabled, which is PancakeSwap
/// On xLayer:
///   - only DEX0 will be enabled, which is PotatoSwap
/// On Monad:
///   - DEX0 is Uniswap
///   - DEX1 is PancakeSwap
///   - DEX2 is Monday
/// Note that, currently, we only support at most 3 DEXes
/// We may add more DEXes in the future if needed
enum DEXId {
    DEX0,
    DEX1,
    DEX2
}

/// @dev Enum for DEX pool types
enum PoolType {
    V2, // Uniswap V2 style pools
    V3 // Uniswap V3 style pools
}

/// @dev Packed DEX pool information
struct PackedDexPool {
    address pool; // 160 bits: pool address
    uint24 fee; // 24 bits: fee tier (for V3), 0 for V2
    PoolType poolType; // 8 bits: enum for pool type
    uint64 unused; // 64 bits: reserved for future use
}