Launch Tokens

curl --request POST "https://funcs.flap.sh/api/upload" \
  -F 'operations={"query":"mutation Create($file: Upload!, $meta: MetadataInput!) { create(file: $file, meta: $meta) }","variables":{"file":null,"meta":{"description":"My token","website":"https://example.com","twitter":null,"telegram":null,"creator":"0x0000000000000000000000000000000000000000"}}}' \
  -F 'map={"0":["variables.file"]}' \
  -F '0=@./image.png;type=image/png'
# → {"data":{"create":"bafkrei…"}}   ← the metadata CID

import { getContractAddress, keccak256, toBytes, toHex, type Address, type Hex } from "viem";
import { generatePrivateKey } from "viem/accounts";

function findVanitySalt(suffix: "7777" | "8888", tokenImpl: Address, portal: Address) {
  // EIP-1167 minimal-proxy init code for `tokenImpl`
  const bytecode = ("0x3d602d80600a3d3981f3363d3d373d3d3d363d73" +
    tokenImpl.slice(2).toLowerCase() +
    "5af43d82803e903d91602b57fd5bf3") as Hex;
  const predict = (salt: Hex) =>
    getContractAddress({ from: portal, salt: toBytes(salt), bytecode, opcode: "CREATE2" });

  let salt = keccak256(toHex(generatePrivateKey())); // any random 32-byte seed
  while (!predict(salt).toLowerCase().endsWith(suffix)) salt = keccak256(salt);
  return { salt, token: predict(salt) };
}

/// tokenVersion must be TOKEN_TAXED_V3 (6) or TOKEN_V3_PERMIT (7); msg.value must equal SALT_LOCK_FEE().
function lockSalt(bytes32 salt, TokenVersion tokenVersion) external payable;

function newTokenV6(NewTokenV6Params calldata params) external payable returns (address token);

struct NewTokenV6Params {
    string name; string symbol; string meta;
    DexThreshType dexThresh; bytes32 salt; MigratorType migratorType;
    address quoteToken; uint256 quoteAmt; address beneficiary;
    bytes permitData; bytes32 extensionID; bytes extensionData;
    DEXId dexId; V3LPFeeProfile lpFeeProfile;
    uint16 buyTaxRate; uint16 sellTaxRate; uint64 taxDuration; uint64 antiFarmerDuration;
    uint16 mktBps; uint16 deflationBps; uint16 dividendBps; uint16 lpBps;   // must sum to 10000
    uint256 minimumShareBalance;    // ≥ 10,000 tokens when dividendBps > 0
    address dividendToken;
    address commissionReceiver;
    TokenVersion tokenVersion;      // TOKEN_TAXED_V3 (6)
}

const params = {
  name: "My Token", symbol: "MTK", meta: metadataCid,
  dexThresh: 1,                     // 80%
  salt,                             // 7777 suffix, Tax Token V3 Impl
  migratorType: 1,                  // V2_MIGRATOR (required for tax tokens)
  quoteToken: zeroAddress,          // BNB
  quoteAmt: parseEther("0.1"),      // creator's first buy
  beneficiary: myWallet,
  permitData: "0x", extensionID: zeroHash, extensionData: "0x",
  dexId: 0, lpFeeProfile: 0,
  buyTaxRate: 300, sellTaxRate: 500,
  taxDuration: 365n * 86400n, antiFarmerDuration: 3600n,
  mktBps: 4000, deflationBps: 0, dividendBps: 6000, lpBps: 0,
  minimumShareBalance: parseEther("10000"),
  dividendToken: zeroAddress,       // pay dividends in the quote token
  commissionReceiver: zeroAddress,
  tokenVersion: 6,                  // TOKEN_TAXED_V3
};
await portal.write.newTokenV6([params], { value: params.quoteAmt });

function newTokenV6WithVault(NewTokenV6WithVaultParams calldata params) external payable returns (address token);
// NewTokenV6WithVaultParams = NewTokenV6Params − beneficiary + { address vaultFactory; bytes vaultData; }

const params = {
  ...taxTokenParams,                // as above, without `beneficiary`
  mktBps: 8000, dividendBps: 2000,  // 80% of the tax to the vault, 20% to holders
  vaultFactory: MY_VAULT_FACTORY,
  vaultData: encodeAbiParameters(   // the factory's own format, here (uint256 maxReward, uint256 cooldown)
    [{ type: "uint256" }, { type: "uint256" }],
    [parseEther("0.1"), 3600n],
  ),
};
await vaultPortal.write.newTokenV6WithVault([params], { value: params.quoteAmt });

function newTokenV7(NewTokenV7Params calldata params) external payable returns (address token);

enum FeeType { NONE, MARKETING_OR_VAULT, DIVIDEND, DEFLATION, LP_BPS }

struct FeeConfig {
    FeeType feeType;
    uint16 bps;
    address marketingAddress;     // MARKETING_OR_VAULT only
    address dividendToken;        // DIVIDEND only
    uint256 minimumShareBalance;  // DIVIDEND only, ≥ 10,000 tokens
}

struct NewTokenV7Params {
    string name; string symbol; string meta;
    DexThreshType dexThresh; bytes32 salt; MigratorType migratorType;
    address quoteToken; uint256 quoteAmt; bytes permitData;
    bytes32 extensionID; bytes extensionData; DEXId dexId;
    uint16 buyTaxRate; uint16 sellTaxRate; uint64 taxDuration; uint64 antiFarmerDuration;
    address commissionReceiver;
    TokenVersion tokenVersion;      // TOKEN_V3_PERMIT (7)
    FeeConfig[4] feeConfigs;        // replaces beneficiary + mktBps/deflationBps/dividendBps/lpBps
}

const none = { feeType: 0, bps: 0, marketingAddress: zeroAddress, dividendToken: zeroAddress, minimumShareBalance: 0n };
const params = {
  name: "My Token", symbol: "MTK", meta: metadataCid,
  dexThresh: 1, salt,               // 8888 suffix, Standard Token V3 Impl
  migratorType: 3,                  // PCS_INFINITY_CL_MIGRATOR
  quoteToken: zeroAddress, quoteAmt: parseEther("0.1"), permitData: "0x",
  extensionID: zeroHash, extensionData: "0x", dexId: 0,
  buyTaxRate: 0, sellTaxRate: 0, taxDuration: 0n, antiFarmerDuration: 0n,
  commissionReceiver: zeroAddress,
  tokenVersion: 7,                  // TOKEN_V3_PERMIT
  feeConfigs: [
    { feeType: 2, bps: 10000, marketingAddress: zeroAddress,
      dividendToken: zeroAddress,                   // must equal quoteToken
      minimumShareBalance: parseEther("10000") },
    none, none, none,
  ],
};
await portal.write.newTokenV7([params], { value: params.quoteAmt });

function newTokenV7WithVault(NewTokenV7WithVaultParams calldata params) external payable returns (address token);
// NewTokenV7WithVaultParams = NewTokenV7Params + { address vaultFactory; bytes vaultData; }

const params = {
  ...nonTaxParams,                  // as above
  feeConfigs: [
    { feeType: 1, bps: 10000, marketingAddress: myWallet,   // placeholder → replaced by the vault
      dividendToken: zeroAddress, minimumShareBalance: 0n },
    none, none, none,
  ],
  vaultFactory: VAULT_FACTORY,       // must be one of the accepted factories (see the limits above)
  vaultData,                         // that factory's format, from its vaultDataSchema()
};
await vaultPortal.write.newTokenV7WithVault([params], { value: params.quoteAmt });

const quoteAmt = parseUnits("10", 18);                       // 10 USDT first buy
await usdt.write.approve([VAULT_PORTAL, quoteAmt]);          // the VaultPortal, not the Portal
await vaultPortal.write.newTokenV6WithVault([{
  ...params,
  quoteToken: USDT, quoteAmt, permitData: "0x",
  vaultFactory: MY_VAULT_FACTORY,                            // isQuoteTokenSupported(USDT) == true
  vaultData,
  dividendToken: USDT,                                       // pay holders in the quote token
}]); // no `value`