Unruggable Meme Framework

The Unruggable framework follows a two-step process to create a memecoin:

1. Deploy the Memecoin

Use the Factory contract to deploy a new Memecoin contract. You must specify:

• The owner of the memecoin
• Name
• Symbol
• Total supply

The resulting Memecoin is ERC20 compliant and includes framework-specific functions like is_launched, get_team_allocation, and liquidity_type.

2. Launch on an Exchange

Once deployed, you must launch the token on an exchange. You need to provide:

• The address of the memecoin
• Duration of transfer restrictions
• Maximum percentage of total supply allowed in a single transaction (while restrictions are active)
• Address of the quote token (e.g., ETH or STRK)

Launching on Jediswap

Requires providing an amount of liquidity in quote tokens and an unlock time for the LP tokens. The liquidity position is transferred to a locker for a configurable duration (minimum 6 months).

Launching on Ekubo (Capital Efficient)

Ekubo launching allows for liquidity within fixed bounds, meaning you don't need a large amount of quote tokens. The process is automated via the EkuboLauncher:

1. The team sends quote token liquidity (covering their team allocation at the starting price) to the Factory.
2. The Factory creates liquidity positions in two steps, concentrating the team's allocation in the first tick.
3. The Factory uses the provided quote tokens to buy back the team's tokens from the pool and transfers them to specified initial holders.
4. The principal liquidity position is held by the EkuboLauncher contract and is locked forever. Owners can withdraw earned fees via this contract.

Liquidity for launched memecoins is categorized into two main types via the LaunchedLiquidity union:

1. JediswapLiquidity: Uses LiquidityType.JEDISWAP_ERC20 or LiquidityType.STARKDEFI_ERC20. It requires a lockPosition (string) and quoteAmount (string).
2. EkuboLiquidity: Uses LiquidityType.EKUBO_NFT. It requires an ekuboId (string), startingTick (number), poolKey (an EkuboPoolKey object), and bounds (an EkuboBounds object).

Both types inherit BaseLiquidity properties: lockManager, unlockTime, owner, and quoteToken.

export type JediswapLiquidity = {
  type: LiquidityType.JEDISWAP_ERC20 | LiquidityType.STARKDEFI_ERC20
  lockPosition: string
  quoteAmount: string
} & Omit<BaseLiquidity, 'type'>

export type EkuboLiquidity = {
  type: LiquidityType.EKUBO_NFT
  ekuboId: string
  startingTick: number
  poolKey: EkuboPoolKey
  bounds: EkuboBounds
} & Omit<BaseLiquidity, 'type'>

Use createForm to define a sequence of interactive steps (fields) for a user in a specific chat. A form can contain text fields (for free-form user input with optional Zod validation) or choice fields (for inline keyboard buttons).

To use a form, you must:

1. Define the fields using defineField to ensure type safety.
2. Initialize the form with createForm(chatId, fields).
3. Register the form in the global Forms registry using Forms.setForm(chatId, form).
4. Use form.setActiveField(fieldName) to prompt the user for the next piece of data.

The bot automatically handles incoming message events for text fields and callback_query events for choice fields, triggering the respective handler functions defined in your fields.

import { createForm, defineField, Forms } from './utils/form';
import { z } from 'zod';

const chatId = 12345;

const form = createForm(chatId, {
  userName: defineField({
    type: 'text',
    validation: z.string().min(3),
    message: 'Please enter your username:',
    handler: ({ value, msg }) => {
      console.log(`User entered: ${value}`);
      // Move to next field
      form.setActiveField('age');
    }
  }),
  age: defineField({
    type: 'choice',
    choices: [
      { key: 'young', title: 'Young' },
      { key: 'old', title: 'Old' }
    ],
    message: 'Select your age group:',
    handler: ({ value, query }) => {
      console.log(`User chose: ${value}`);
      Forms.resetForm(chatId);
    }
  })
});

// Register the form so the bot listeners can find it
Forms.setForm(chatId, form);

// Start the first step
form.setActiveField('userName');

The Telegram bot provides a multi-step interactive form to launch an unruggable memecoin. The process involves specifying the token address, selecting an AMM, configuring team allocations, setting anti-bot parameters, and defining liquidity lock terms.

Key Launch Parameters:

• Token Address: Must be a valid, unlaunched unruggable memecoin address.
• AMM Selection: Choose between available AMMs (e.g., EKUBO or standard AMMs).
• Team Allocations: Up to 10 addresses can be assigned tokens. The total allocation cannot exceed 10% of the total supply.
• Hold Limit: A percentage (recommended 1%) that limits how much a single holder can own.
• Anti-bot Period: A time (hh:mm format) after which anti-bot features are disabled.
• Starting Market Cap: The initial USD market cap (recommended $10.00).
• Liquidity Lock: For standard AMMs, you can specify a duration in months (6-24) or type forever for a permanent lock.