Suicoins now supports Smart Router Swapping, an advanced feature powered by our esteemed partner Aftermath Finance. This powerful tool ensures you always get the best rates for your swaps on the Sui Network.

Smart-Order Router (SOR)

The Smart-Order Router (SOR) is an innovative DEX aggregator designed for the Sui network. It provides users with optimal swap prices by connecting to multiple liquidity pools and decentralized exchanges (DEXes) in the ecosystem.

Key Features

1. Comprehensive Aggregation

   • SOR searches every liquid DEX on Sui, ensuring the best possible swap rates.

   • As the DeFi ecosystem grows, SOR continuously integrates with new DEXes.

2. Trade Optimization

   • Splits large trades across multiple DEXes and liquidity pools to minimize slippage and improve trade efficiency.

3. Simplicity and Security

   • Leverages Sui’s Programmable Transaction Blocks (PTBs) to combine complex, multi-step swap routes into a single, secure transaction.

4. Permissionless Composability

   • Integrates seamlessly with other dApps, wallets, and DeFi tools.

   • Current use cases include integrations with:

     • Nightly Wallet swaps

     • Scallop Tools

     • Suiba Telegram bot

Why Use SOR on Suicoins?

• Best Rates, Every Time: SOR searches all DEXes on Sui to guarantee competitive trade prices.

• One-Click Swaps: Even for complex transactions, only one user action is required.

• Efficient and Reliable: SOR ensures minimal slippage by splitting large trades and optimizing liquidity utilization.

Supported Liquidity Pools and DEXes

The SOR connects to a wide range of liquidity pools and platforms, including:

• Aftermath

• DeepBook

• Cetus

• Turbos

• FlowX

• Kriya

• Suiswap

• BlueMove

How It Works

1. Search for Liquidity: The SOR scans all integrated DEXes and liquidity pools to identify the best available trade paths.

2. Optimize the Trade Path: For large trades, the SOR splits transactions into smaller sub-paths to minimize slippage.

3. Batch Execution: Through Sui’s PTBs, the trade is executed in a single transaction, ensuring security and simplicity.

The Smart-Order Router (SOR) makes trading on Suicoins seamless, cost-efficient, and secure—empowering both traders and developers within the Sui ecosystem.

Fees

The Suiplay Airdrop feature enables users and projects to distribute rewards directly to holders of SuiPlay Soulbound NFTs. Whether rewarding Mythics, Exalted, or all Soulbound NFT holders, the Suicoins Airdrop Tool simplifies the process of targeted and efficient reward distribution.

Key Features

1. Targeted Airdrop Distribution

   • Choose between specific groups:

     • Mythics Soulbound NFT Holders

     • Exalted Soulbound NFT Holders

     • All Soulbound NFT Holders

2. Flexible Token Options

   • Distribute any supported token of your choice.

3. Streamlined Process

   • An intuitive interface guides users through the setup, review, and execution of the airdrop.

How It Works

1. Navigate to the Airdrop Tool:

   • Open the Suicoins and select the Airdrop section.

2. Select the Delivery Method:

   • Choose SuiPlay Holders as the method of delivery.

3. Choose the Recipient Group:

   • Select the group of SuiPlay Soulbound NFT holders to airdrop to:

     • Mythics

     • Exalted

     • Everyone

4. Set Token and Amount:

   • Specify the token and the amount to be distributed to each recipient.

5. Review and Confirm:

   • Double-check your transaction details.

   • Approve and confirm the transaction in your wallet.

In this example, we’ve successfully airdropped 0.001 SUI to each SuiPlay Soulbound NFT holder (Mythics and Exalted).

Fees

Interest Math

IPX Coin Standard

Constant Product

BPS

Suicoins serves as the utility layer for all tokens and NFTs on the Sui Network. Its features include:

• A Swap feature powered by Aftermath Finance.

• A DCA (Dollar Cost Averaging) tool.

• An Airdrop feature for seamless reward distribution.

• An Incinerator to help keep your wallet clean by removing unwanted tokens.

• A Send feature powered by Mysten Lab's xkSend for efficient transfers.

• A Merger to free up chain space and declutter your wallet by consolidating assets.

The Dollar-Cost Averaging (DCA) feature on Suicoins allows users to buy into or sell out of tokens gradually over time, reducing the risks associated with market volatility. This feature is designed to provide a systematic approach to trading, making it an ideal choice for both beginners and experienced investors.

Key Features of DCA on Suicoins

1. Automated Buy-In and Sell-Out Strategies

   • Users can automate their investments, purchasing or selling tokens at regular intervals based on their predefined preferences.

2. Active and Historical Monitoring Tools

   • Active DCA Tracker: Monitor ongoing DCA activities in real time to ensure your strategies are on track.

   • Historical Data Analysis: Access detailed records of past DCA activities to study your trading performance and refine strategies.

3. Risk Mitigation Through Averaging

   • Gradual buying and selling helps mitigate the impact of price volatility, making it easier to achieve long-term investment goals.

4. User-Friendly Interface

   • Intuitive tools ensure that setting up, monitoring, and analyzing DCA strategies is seamless, even for those new to DeFi.

Benefits of Using DCA on Suicoins

• Reduce Emotional Trading: By sticking to a systematic plan, users avoid impulsive decisions influenced by market swings.

• Historical Insights: Leverage past DCA data to make informed adjustments to your trading strategies.

• Flexibility: Customize the frequency, token pair, and amount to suit your financial goals.

How It Works

1. Set Up a DCA Plan:

   • Select the token you want to buy or sell and set the frequency and amount.

2. Monitor Active Plans:

   • Use the Active DCA Tracker to check the progress of ongoing strategies in real time.

   • Make adjustments as needed without disrupting the overall plan.

3. Analyze Historical Data:

   • Review detailed records of completed DCA activities, including trade dates, amounts, and market conditions.

   • Use these insights to optimize future trading plans.

Why Use DCA on Suicoins?

• Consistency in Trading: Build wealth over time by regularly investing regardless of market conditions.

• Data-Driven Insights: Gain a deeper understanding of your trading habits and performance through robust historical data.

• Ease of Use: Simplify complex trading strategies with Suicoins’ intuitive DCA tools.

The DCA feature on Suicoins empowers users to trade systematically and analyze their performance, fostering a disciplined and informed approach to cryptocurrency trading.

Fee

Suicoins integrates with Mysten Labs' zkSend to provide an innovative way to send and claim digital assets securely and anonymously. This feature supports any publicly transferrable asset and enables users to create claim links with ease.

Effortlessly send coins, NFTs, and other assets on the Sui Network in stealth mode within seconds.

Key Features

1. Create zkSend Claim Links

   • Generate claimable links for secure and private transfers of assets.

   • Support for all publicly transferrable assets, including:

     • Coins

     • NFTs

     • Other digital tokens

2. Two Modes of Usage

   • Simple Link: Combine multiple assets (e.g., coins, NFTs) into a single claimable link.

   • Bulk Link: Distribute a specific coin through multiple claimable links, ideal for batch transactions. (Note: This feature is exclusive to coins.)

3. Anonymity and Speed

   • Send and claim assets in stealth mode, ensuring privacy.

   • Transactions are completed within seconds.

How It Works

1. Choose a Mode:

   • Select either the Simple Link or Bulk Link option, depending on your transfer requirements.

2. Prepare the Assets:

   • For Simple Link: Add various assets like coins and NFTs to be included in one claimable link.

   • For Bulk Link: Specify the coin and number of claimable links to create.

3. Generate and Share the Link:

   • Suicoins will create a zkSend claim link based on your inputs.

   • Share the link with recipients for them to claim the assets.

4. Claim Assets:

   • Recipients can use the provided link to claim their assets instantly and privately.

Implementation

Developers interested in implementing zkSend functionality can use the following resources:

An innovative tool developed by IPXSui for the Sui Network, the Suicoins Incinerator automates asset burning on the Sui blockchain, simplifying the removal of unwanted NFTs, tokens, and objects from your Sui Wallet. This document provides an overview of its features, usage, and implementation details.

Overview

The Suicoins Incinerator is designed to streamline asset management by allowing users to "burn" or delete digital assets from their Sui Wallet. Whether clearing unwanted tokens, NFTs, or other assets, the Incinerator provides a seamless interface for bulk or individual deletions. This tool helps users declutter their wallets and reclaim Sui in some cases.

Key Features

• Automated Burning: Burn assets in bulk or one-by-one with a single click. Say goodbye to manual transaction processes.

• Space Optimization: Merges multiple assets into one and frees up blockchain space, especially useful when removing scam or unwanted objects.

• Reclaim Sui: By freeing up space, you may recover Sui if the reclaimed value exceeds the transaction cost.

• Clutter Management: Keep your wallet tidy by removing or merging assets you no longer need.

• Enhanced Security: Integrated with suiet_walletGuardians to help users identify and eliminate scam assets.

Getting Started

2. Connect Your Wallet: Ensure you have a compatible wallet connected, such as the Suiet Wallet.

3. Select Assets to Burn: Choose assets from your wallet for burning or merging.

4. Confirm Action: Follow the prompts to confirm your selections for incineration.

Usage Guide

1. Connect Wallet: After opening the Incinerator page, connect your Sui Wallet.

2. Select Assets: Browse your assets, and select either "Bulk Burn" or individual burning options to manage them as desired.

3. Merge Coins or Objects: Use the Incinerator to combine multiple assets into a single entity before burning. This frees up blockchain space.

4. Send to 0x0 Address: Once merged, the Incinerator sends the asset to the 0x0 address, effectively removing it from circulation.

⚠️ Important Warning

Technical Details

The Suicoins Incinerator enables asset management by consolidating multiple coins or objects into a single entity and removing them from circulation. This not only frees up wallet space but may also return Sui to the user if the combined asset value exceeds the transaction fees.

Space Optimization

On Suicoins, burning removes assets and may return Sui to the user by merging objects, provided the reclaimed value is higher than the transaction cost.

WalletGuardians Integration

We are updating our documentation. If you have any urgent questions, please reach out to one of our social channels below.

Join us

Learn more

The Suicoins Airdrop Tool provides a seamless way for projects and individuals to distribute tokens to specific users via CSV files, NFT collection holders, or custom addresses. Whether you need to reward thousands of wallets or target holders of a particular NFT collection, our tool makes the process straightforward and efficient.

Key Features

• Flexible Delivery Options: Distribute tokens using CSV files, to NFT collection holders, or to custom addresses.

• Batch Processing: Airdrops are divided into batches of 500 transactions. For instance, an airdrop to 1,000 wallets will require two batches, with the DApp prompting you to confirm one transaction per batch.

Methods of Delivery

1. CSV File Distribution

Distribute tokens to multiple wallet addresses with customizable amounts for each address. Follow these steps:

1. Prepare a CSV file formatted as follows:

   Address

   Amount

   0x123...abc

   100

   0x456...def

   200

2. Upload your prepared CSV file.

3. Choose the token you wish to airdrop.

4. Review and confirm the transactions in your wallet.

Airdrop to NFT Collection Holders

Easily distribute tokens to all holders of a specified NFT collection. Each NFT held acts as a multiplier for the drop amount. Here’s how to do it:

1. Navigate to the Airdrop section and select the token you wish to distribute.

2. Choose the NFT Collection option.

3. Specify the token amount to be airdropped per NFT.

4. Review and confirm the transaction in your wallet.

Note:

• The distribution is proportional to the number of NFTs a wallet holds. For example, a holder with 3 NFTs will receive 3 times the specified amount.

Custom Address Airdrops

Send the same amount of tokens to multiple wallet addresses.

Steps to use this feature:

1. Navigate to the Airdrop section and select the token you wish to airdrop.

2. Choose the Custom Addresses option.

3. Enter wallet addresses, one per line.

4. Specify the token amount to distribute to each address.

5. Review and confirm the transaction in your wallet.

Important

• Batch Transactions: Airdrops are limited to 500 wallets per batch. For larger distributions, you’ll need to confirm multiple transactions.

• Verification: After completing an airdrop, all details can be checked on the Sui Explorer.

Fees

Think of your wallet as a digital garage—cluttered with tiny amounts of leftover coins. The Suicoins Merger feature lets you tidy things up, combining small amounts of various tokens to free up space and potentially uncover hidden value.

It’s like finding a forgotten bill in your old jacket pocket or discovering spare change in your couch cushions—only cooler and crypto-focused.

Key Benefits of the Merger

1. Wallet Optimization

   • Consolidate your wallet by merging tiny balances into more meaningful amounts.

   • Free up valuable space on the Sui Network.

2. Discover Hidden Value

   • Combine overlooked small balances of coins and potentially score extra $SUI.

3. User-Friendly and Efficient

   • A seamless process designed to help you manage your digital assets with minimal effort.

How It Works

1. Access the Merger Tool:
2. Select Coins to Merge:

   • Choose the tiny coin balances you want to consolidate.

3. Execute the Merge:

   • Suicoins will combine the selected balances and free up wallet space.

   • Any additional value discovered (e.g., $SUI) will be credited to your wallet.

Why Use Suicoins Merger?

• Simplify Your Wallet: No more managing countless tiny balances.

• Optimize Network Space: Help reduce clutter on the Sui Network.

• Find Hidden Rewards: Merge and unlock the potential of your unused crypto.

MemeFi... what? Do you mean DeFi

MemeFi (Meme Coin + Finance) are DeFi applications designed specifically for meme coins. Meme coins have carved their presence in the web3 industry as a vehicle to grab attention, new users and build culture. We have seen social trends and memes spread world wide because of meme coins.

Dapps built for meme coins need to take into account their users are not afraid of risk, fees, high slippage nor volatility. They provide developers with the opportunity to explore new instruments as they are as constraint like in DeFi.

Ok, What is Memez.gg ?!

Memez.gg is an end to end protocol to launch, bootstrap liquidity and trade meme coins.

• Memez.Fun is a virtual liquidity launchpad with three different distribution mechanisms to price meme coins and bootstrap liquidity.

• Memez.Dex is an exchange designed to appreciate meme coins by implementing special mechanisms that benefit buyers and discourage sellers.

All Meme coins created on Memez use the IPX Coin Standard

Official Links

Overview

The Suicoins Terminal is an open-source, lightweight adaptation of the Suicoins Swap feature, designed to enable seamless, end-to-end cryptocurrency swaps that can be integrated effortlessly into your platform.

Benefits of the Suicoins Terminal:

• Secure on-site trading on the Sui Network

• Enhanced user convenience with no need to navigate away from your platform

• Streamlined user experience to improve trust and engagement

Key Features

Predefined Configurations

Define input and output tokens easily for precise trading pair setups.

Restricted Trading Options

Restrict swaps to specific tokens for enhanced security and platform focus.

Trading Fees Structure

The Suicoins Terminal applies a simple fee structure for swaps:

• 0.15% for Memecoin Project.

• 0.15% for Suicoins.

These fees are automatically calculated and deducted during each transaction.

How to Integrate

Vanilla SDK Integration

Follow these steps to integrate the Vanilla SDK into your project:

Step 1: Add the SDK Script

Include the following script in your HTML file:

Step 2: Add the Terminal Container

Add an empty <div> with the required id attribute to your code:

Step 3: Initialize the Terminal

Initialize the Suicoins Terminal with your custom parameters:

React SDK Integration

Step 1: Install the SDK

Use one of the following package managers to add the SDK to your React project:

Step 2: Import and Configure the Terminal Component

Import the SwapTerminal component and configure it with the necessary parameters:

For any questions or assistance, our team is here to help—don’t hesitate to reach out.

Constructor

Allows the SDK to be initiated with custom data.

How to use:

import { getFullnodeUrl } from '@mysten/sui/client';
import {
  MemezPumpSDK,
  MemezStableSDK,
  PACKAGES,
  SHARED_OBJECTS,
  Network,
} from '@interest-protocol/memez-fun-sdk';

// Default settings (Testnet)
const memezPumpTestnet = new MemezPumpSDK();

// Default settings (Testnet)
const memezStableTestnet = new MemezStableSDK();

// Custom setup
const memezPump = new MemezPumpSDK({
  fullNodeUrl: getFullnodeUrl('mainnet'),
  network: Network.Mainnet,
  packages: PACKAGES[Network.Mainnet],
  sharedObjects: SHARED_OBJECTS[Network.Mainnet],
});

Arguments

• fullNodeUrl {string} - Url to initiate the Sui Client RPC

newPumpPool

Creates a pool using the Pump invariant.

How to use:

  const recipient = keypair.toSuiAddress();

  const tx = new Transaction();

  const [creationSuiFee, devPurchase] = tx.splitCoins(tx.gas, [
    tx.pure.u64(30_000_000n),
    tx.pure.u64(1_000_000_000n),
  ]);

  const { metadataCap } = await memezPumpTestnet.newPool({
    tx,
    configurationKey,
    metadata: {
      X: 'https://x.com/Meme',
      Website: 'https://meme.xyz/',
      GitHub: 'https://github.com/meme',
      videoUrl: 'https://memez.gg',
    },
    creationSuiFee,
    memeCoinTreasuryCap: TREASURY_CAP,
    devPurchaseData: {
      developer: recipient,
      firstPurchase: devPurchase,
    },
    migrationWitness: MIGRATOR_WITNESSES.testnet.TEST,
    totalSupply: TOTAL_SUPPLY,
    useTokenStandard: true,
    quoteCoinType: SUI_TYPE_ARG,
  });
  tx.transferObjects([metadataCap], tx.pure.address(recipient));

  await executeTx(tx);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• creationSuiFee {object} - The Sui fee to create a MemezPool.

• memeCoinTreasuryCap {string} - The meme coin treasury cap.

• totalSupply {string | number | bigint} - The total supply of the meme coin.

• useTokenStandard {boolean} - Whether to use the token standard for the MemezPool.

• devPurchaseData {object} - An object containing the quote Coin to to perform the first buy tx and the address of the person who can claim the coins.

• metadata {object} - A record of the social metadata of the meme coin.

• configurationKey {string} - The configuration key to use for the MemezPool.

• migrationWitness {string} - The migration witness to use for the MemezPool.

• stakeholders {string[]} - The addresses of the stakeholders. It can be empty or undefined.

• quoteCoinType {string} - The quote coin type to use for the MemezPool.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• metadataCap {object} - The metadata object.

pump

Swaps quote coin for a meme coin in a pool.

How to use

const tx = new Transaction();

const suiCoin = tx.splitCoins(tx.gas, [tx.pure.u64(103n * POW_9)]);

const { memeCoin, tx: tx2 } = await memezPumpTestnet.pump({
  pool: TEST_POOL_ID,
  quoteCoin,
  tx,
});

tx2.transferObjects([memeCoin], keypair.toSuiAddress());

await executeTx(tx2);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• quoteCoin {object} - The quote coin to sell for the meme coin.

• minAmountOut {string | number | bigint} - The minimum amount of meme coin expected to be received.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• memeCoin {object} - The meme coin bought.

dump

Swaps meme coin for quote coin in a pool.

How to use

const tx = new Transaction();

const pool = await memezTestnet.getPumpPool(TEST_POOL_ID);

const memeCoin = await getCoinOfValue({
  tx,
  coinType: pool.memeCoinType,
  coinValue: 990500n * 10n,
});

const { quoteCoin, tx: tx2 } = await memezPumpTestnet.dump({
  pool: TEST_POOL_ID,
  memeCoin,
  tx,
});

tx2.transferObjects([quoteCoin], keypair.toSuiAddress());

await executeTx(tx2);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• memeCoin {object} - The meme coin to sell for Sui coin.

• minAmountOut {string | number | bigint} - The minimum amount of sui coin expected to be received.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• quoteCoin {object} - The Quote coin bought.

pumpToken

Swaps quote coin for the meme token using the Token Standard.

How to use

const tx = new Transaction();

const quoteCoin = tx.splitCoins(tx.gas, [tx.pure.u64(105n * POW_9)]);

const { memeToken, tx: tx2 } = await memezPumpTestnet.pumpToken({
  pool: TEST_POOL_ID,
  quoteCoin,
  tx,
});

const { tx: tx3 } = await memezPumpTestnet.keepToken({
  memeCoinType: MEME_COIN_TYPE,
  token: memeToken,
  tx: tx2,
});

await executeTx(tx3);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• quoteCoin {object} - The Sui coin to sell for the meme coin.

• minAmountOut {string | number | bigint} - The minimum amount meme coin expected to be received.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• memeToken {object} - The meme token bought.

• memeCoinType {string} - The type of the meme coin.

dumpToken

Swaps the meme token for quote coin.

How to use

const tx = new Transaction();

const { quoteCoin, tx: tx2 } = await memezPumpTestnet.dumpToken({
  pool: TEST_POOL_ID,
  memeToken:
      '0x0a256522091a350e3cc3ac86982608803bce754ede1199785227bfc822603b71',
  tx,
});

tx2.transferObjects([quoteCoin], tx.pure.address(keypair.toSuiAddress()));

await executeTx(tx2);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• memeToken {object} - The meme token to sell for Sui coin.

• minAmountOut {string | number | bigint} - The minimum amount sui coin expected to be received.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• quoteCoin {object} - The quote coin bought.

devClaim

Allows the developer to claim the first purchased coins. It can only be done after the pool migrates.

How to use

const { memeCoin, tx } = await memezTestnet.devClaim({
  pool: TEST_POOL_ID,
});

tx.transferObjects([memeCoin], keypair.toSuiAddress());

await executeTx(tx);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• memeCoin {object} - The meme coin bought by the developer during deployment.

keepToken

Utility function to return the Token to the sender.

How to use

const { tx: tx3 } = await memezPumpTestnet.keepToken({
  memeCoinType: MEME_COIN_TYPE,
  token: memeToken,
  tx: tx2,
});

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• token {string | object} - The objectId of the meme token to keep.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• memeCoin {object} - The meme coin bought by the developer during deployment.

toCoin

Converts a meme token to a meme coin. This is for pools that use the Token Standard. It can only be done after the pool migrates.

How to use

const { memeCoin, tx } = await memezPumpTestnet.toCoin({
  pool: TEST_POOL_ID,
  memeToken: TOKEN_ID,
});

tx.transferObjects([memeCoin], tx.pure.address(keypair.toSuiAddress()));

await executeTx(tx);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• memeToken {object} - The meme token to convert to a meme coin.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• memeCoin {object} - The meme coin converted from token.

migrate

Migrates the pool to DEX based on the MigrationWitness.

How to use

const { tx, migrator } = await memezPumpTestnet.migrate({
  pool: TEST_POOL_ID,
});

const migratorSDK = new MigratorSDK();

const { tx: tx2 } = migratorSDK.migrate({
  tx,
  migrator,
  memeCoinType: MEME_COIN_TYPE,
});

await executeTx(tx2);

Arguments

• tx {object} - Sui client Transaction class to chain move calls.

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

Return

• tx {object} - Sui client Transaction class to chain move calls.

• migrator {object} - The hot potato migrator containing the balances.

quotePump

Quotes the amount of meme coin received after selling the quote coin.

How to use

import { memezTestnet, POW_9, TEST_POOL_ID } from '../utils.script';

const { memeAmountOut, swapFeeIn } = await memezPumpTestnet.quotePump({
  pool: TEST_POOL_ID,
  amount: 15n * POW_9,
});
  
console.log({ memeAmountOut, swapInFee });

Arguments

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• amount {string | number | bigint} - The amount of Sui being sold.

Return

• memeAmountOut {bigint} - The amount of meme coin that will be received.

• swapFeeIn {bigint} - The swap fee paid in Sui.

quoteDump

Quotes the amount of quote coin received after selling the meme coin.

How to use

import { memezTestnet, POW_9, TEST_POOL_ID } from '../utils.script';


const { amountOut, swapFeeIn, burnFee } = await memezPumpTestnet.quoteDump({
  pool: TEST_POOL_ID,
  amount: 1_500_000n * POW_9,
});

console.log({ amountOut, swapFeeIn, burnFee });

Arguments

• pool {string | object} - The objectId of the MemezPool or the full parsed pool.

• amount {string | number | bigint} - The amount of Mem coin being sold.

Return

• quoteAmountOut {bigint} - The amount of quote coin that will be received.

• swapFeeIn {bigint} - The swap fee paid in Meme coin.

• burnFee {bigint} - Burn fee in meme coin.

getPumpData

Returns the Pump configuration for a specific integrator using a configuration key.

How to use

import { CONFIG_KEYS } from '../../memez';
import { log, memezTestnet } from '../utils.script';


const pumpData = await memezPumpTestnet.getPumpData({
    configurationKey: CONFIG_KEYS.testnet.DEFAULT,
    totalSupply: 1e9 * 1e9,
    quoteCoinType: QUOTE_COIN_TYPE
 });

log(pumpData);

Arguments

• configurationKey {string} - The struct tag of a configuration key. E.g. package::module::Key

• totalSupply {string | bigint | number} - The total supply of the meme coin. E.g. 1 Sui would be 1e9.

Return

• burnTax - The tax value of the burner in bps.

• virtualLiquidity - The starting virtual liquidity in the pool in Sui.

• targetQuoteLiquidity - The amount of quote required for the pool to migrate.

• liquidityProvision - The amount of Meme coin that will be supplied to a DEX after migration.

Virtual ... what?

In layman terms, Memez.fun is a platform to launch meme coins and bootstrap liquidity. The protocol supports three launch strategies:

• Auction (High Risk): It mimics a dutch auction in which the meme coin starts at a very high price and quickly declines until a fair price is found by traders.

• Pump (High Risk): The traditional method pioneered by pump.fun. The coin starts at a floor price to avoid early buyers from having a very large advantage.

• Stable (Low Risk): It provides a fixed trading price for the coin until the target sui amount is acquired. Unlike a normal presale platform, users can exit their position anytime before the target raise is reached.

Phases

The pools can be in three different phases:

Bonding

All pools start at this phase as soon as they are created. In this phase users are allowed to buy and sell freely.

Migrating

This is triggered once the pool collects enough Sui to migrate from Memez.fun to a DEX. During this time, no trading is allowed. Anyone can call the migration function to move the liquidity.

Migrated

It indicates that a pool has successfully migrated. No trading is allowed in this phase.

Migration

All pools on Memez.fun migrate once a certain amount of Sui is accumulated. This is referred as Target Sui Amount. Once this requirement is meant the liquidity is moved from our platform to a DEX chosen by the deployer.

Closed Loop Tokens

Miscellaneous

Dynamic Supply

Meme coins on Memez.fun can have any supply. The contracts do not enforce a supply of 1 billion as other launchpads. Moreover, all coins are burnable.

Upgradeable Metadata

Meme coins created on Memez.fun can have their metadata updated by the deployer.

• Name

• Symbol

• Description

• Icon

Configurable Features

When creating a coin, users define key attributes:

Basic Information

• Coin Name – Unique identifier for the token.

• Ticker – Short symbol (e.g., ROOT for Rootlets).

• Description – Brief summary of the token’s purpose.

• Logo – Custom image representing the coin.

Supply Settings

• Total Supply – Initial token amount (supports up to 9 decimal places).

• Maximum Supply – Hard cap on total token supply.

Advanced Features

• Burnable – Tokens can be removed from circulation, with burn permissions configurable.

• Mintable – Allows the deployer to create additional tokens up to the maximum supply.

• Editable Metadata – Enables modifications to name, ticker, description, and logo after deployme

Creating Coin on Memez GG

On the video below we have launched a token with all the functionalities mentioned above. Here are the details of the token created:

• Name: Kumo

• Ticker: Kumo

• Description: Kumo the cat

• Supply: 1,000,000

• Max Supply: 1000,000,000

• Functions enabled: Burnable, Mintable and Editable

🎥 Watch the video for a step-by-step walkthrough.

Editing The Metadata

After creating a coin with the Edit function enabled, you can update its metadata at any time. Now, let's rebrand the Kumo coin we created earlier by updating the following details:

• Name: Rootlets

• Ticker: ROOT

• Description: “Just Root it”

• Image: A Rootlet PFP

🎥 Watch the video for the step-by-step walkthrough.

And just like that—within a few clicks, we’ve successfully rebranded the entire coin!

Managing Tokens: Burning & Minting

Now that you know how to create and change it's metadata, let's explore two important functions—burning and minting tokens. These actions allow you to manage the token supply dynamically.

Remember that when we created the token, we enabled the ability to burn and mint tokens, setting the initial supply to 1,000,000 and the max supply to 1,000,000,000. This means you can perform burns and mints freely within the range of 0 to 1,000,000,000 tokens.

On the video below, we'll use the rebranded Rootlets token to demonstrate both processes. In this case we will first mint 100,000 tokens and then mint the same amount.

Migrating a Coin from Suicoins to Memez GG

Introduction

In this guide, we will walk through the process of migrating a coin created on Suicoins to Memez GG. This migration ensures that the coin follows the IPX Coin Standard, gaining key functionalities such as:

• Burning tokens

• Minting new tokens

• Editing metadata

By the end of this tutorial, your migrated coin will have all of these features.

Prerequisites

Step 1: Creating a Coin on Suicoins

1. Navigate to Suicoins and click Create Token.

2. Fill in the token details. For this tutorial, we will use the following example:

   • Name: Prime Machine

   • Ticker: PRIME

   • Description: Suii is the endgame and starts with Studio Mirai.

   • Image: Prime Machine #2059

   • Supply: 1 million tokens

3. Important Step: Do not set a fixed supply. Setting a fixed supply sends the treasury cap to a dead address, preventing migration. By keeping a flexible supply, the treasury cap remains with the deployer.

4. Confirm the transaction in your wallet.

Once confirmed, the token is successfully created on Suiicoins.

Step 2: Migrating to Memez GG

1. Navigate to Memez GG and click Create Token, then select Migrate.

2. Choose the token you wish to migrate (e.g., Prime Machine).

3. Configure the token settings. Memez GG provides options similar to the token creation process but now includes the ability to enable all functionalities of the IPX Coin Standard. Enable:

   • Burning tokens

   • Minting new tokens

   • Editing metadata

4. Set a new max supply (e.g., 1 billion tokens).

5. Confirm the transaction in your wallet.

🎥 Watch the video for the step-by-step walkthrough.

MemezPool

It represents a Memez Pool.

export interface MemezPool<T> {
  objectId: string;
  poolType: string;
  curveType: string;
  memeCoinType: string;
  quoteCoinType: string;
  usesTokenStandard: boolean;
  ipxMemeCoinTreasury: string;
  metadata: Record<string, string>;
  migrationWitness: string;
  progress: string;
  stateId: string;
  dynamicFieldDataId: string;
  curveState: T;
}

• objectId: The Sui Object id of this pool.

• poolType: The struct tag of the pool.

• curveType: It denotes the possible variants of the pool. E.g. Stable, Auction and Pump.

• memeCoinType: The struct tag of the Meme coin.

• quoteCoinType: The struct tag of the Quote coin.

• usesTokenStandard: Denotes if the pool uses the token standard.

• ipxMemeCoinTreasury: The id of the Meme coin Treasury.
• metadata: A map of the meme coin metadata.

• migrationWitness: The struct tag of the migrator witness. It shows to which DEX the pool is going to migrate to.

• progress: The current status of the pool. E.g. Bonding, Migrating or Migrated.

• stateId: The id of of the state object to fetch the inner state.

• dynamicFieldDataId: The id of the dynamic field holding the inner state.

• curveState: The inner state related to the variant.

PumpState

Represents the state of the Pump Pool that will be saved in the property curveState in the Memez Pool.

export interface PumpState {
  devPurchase: bigint;
  liquidityProvision: bigint;
  migrationFee: bigint;
  virtualLiquidity: bigint;
  targetQuoteLiquidity: bigint;
  quoteBalance: bigint;
  memeBalance: bigint;
  burnTax: number;
  swapFee: number;
  allocation: Allocation
}

• devPurchase: The coins bought by the developer.

• liquidityProvision: The amount of meme coin that will be added liquidity.

• migrationFee: The payment in Sui that will be charged during migration.

• virtualLiquidity: The virtual Sui liquidity to set a floor price.

• targetSuiLiquidity: The amount of Sui required to migrate.

• quoteBalance: The current amount of Sui in the pool.

• memeBalance: The amount of meme coin in the pool.

• burnTax: The burn tax percentage in bps.

• swapTax: The swap fee percentage in bps.

• allocation: Balance of meme coins to be sent o stake holders after migration.

Network

An enum referring to the current network being used.

export enum Network {
  Mainnet = 'mainnet',
  Testnet = 'testnet',
}

• Mainnet: Sui Network main net

• Testnet: Sui Network test net.

Packages

An object containing the packages to interact with Memez.

export const PACKAGES = {
  [Network.Mainnet]: {
    MEMEZ_FUN: {
      original: normalizeSuiAddress('0x0'),
      latest: normalizeSuiAddress('0x0'),
    },
    ACL: {
      original: normalizeSuiAddress('0x0'),
      latest: normalizeSuiAddress('0x0'),
    },
    VESTING: {
      original: normalizeSuiAddress('0x0'),
      latest: normalizeSuiAddress('0x0'),
    },
    MEMEZ_MIGRATOR: {
      original: normalizeSuiAddress('0x0'),
      latest: normalizeSuiAddress('0x0'),
    },
    MEMEZ_WITNESS: {
      original: normalizeSuiAddress('0x0'),
      latest: normalizeSuiAddress('0x0'),
    },
  },
  [Network.Testnet]: {
    MEMEZ_FUN: {
      original: normalizeSuiAddress(
        '0x63fed690a1154cfc4b31658443227de047cf3d305179aa5836e177c9efa57854'
      ),
      latest: normalizeSuiAddress(
        '0x63fed690a1154cfc4b31658443227de047cf3d305179aa5836e177c9efa57854'
      ),
    },
    ACL: {
      original: normalizeSuiAddress(
        '0x5d406d0307d260f6ffc01f87960b0c28b8c5c3f0e8e71897b1a924a757232179'
      ),
      latest: normalizeSuiAddress(
        '0x5d406d0307d260f6ffc01f87960b0c28b8c5c3f0e8e71897b1a924a757232179'
      ),
    },
    VESTING: {
      original: normalizeSuiAddress(
        '0xdada5d84429db8d56a775593b2893fc030826055dc84fa47ccdfd4933a63d093'
      ),
      latest: normalizeSuiAddress(
        '0xdada5d84429db8d56a775593b2893fc030826055dc84fa47ccdfd4933a63d093'
      ),
    },
    MEMEZ_MIGRATOR: {
      original: normalizeSuiAddress(
        '0x1c709c9f80361a4fb32a122b46a7381f8f6cf267016fdbf6e87b04622ba3476b'
      ),
      latest: normalizeSuiAddress(
        '0x1c709c9f80361a4fb32a122b46a7381f8f6cf267016fdbf6e87b04622ba3476b'
      ),
    },
    MEMEZ_WITNESS: {
      original: normalizeSuiAddress(
        '0x06267071d0eecfb7d16418cb71da4c7b7941b28208a71086ff3e47731c2d263a'
      ),
      latest: normalizeSuiAddress(
        '0x06267071d0eecfb7d16418cb71da4c7b7941b28208a71086ff3e47731c2d263a'
      ),
    }
  },
};

• MEMEZ_FUN: The address of the core Memez package.

• ACL: The package of the Memez admin package.

• VESTING: The package of the vesting package of Memez package.

• MEMEZ_MIGRATOR: The package of the migrator.

• MEMEZ_WITNESS: A package containing the configuration witnesses.

Shared Objects

An object containing the shared objects to interact with Memez. Each object has a mutable and immutable reference for optimization purposes.

export const SHARED_OBJECTS = {
  [Network.Mainnet]: {
    ACL: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId('0x0'),
      initialSharedVersion: '1',
      mutable,
    }),
    VERSION: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId('0x0'),
      initialSharedVersion: '1',
      mutable,
    }),
    CONFIG: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId('0x0'),
      initialSharedVersion: '1',
      mutable,
    }),
    MIGRATOR_LIST: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId('0x0'),
      initialSharedVersion: '1',
      mutable,
    }),
  } as const,
  [Network.Testnet]: {
    ACL: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId(
        '0x1b5397ee2f6f8ccfb26016c1ed996f25b2277acb9ed5173fa0bed386360960d8'
      ),
      initialSharedVersion: '384530228',
      mutable,
    }),
    MIGRATOR_LIST: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId(
        '0xf35e6124170d1c7618090bed501edd8fc5f8d8f2d053fbc5f12db93300491ab7'
      ),
      initialSharedVersion: '384530230',
      mutable,
    }),
    VERSION: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId(
        '0x0e74ece4efbc1a15b1ff5bd5653e13281f691b9db8faf669b13783ecc414c848'
      ),
      initialSharedVersion: '384530230',
      mutable,
    }),
    CONFIG: ({ mutable }: { mutable: boolean }) => ({
      objectId: normalizeSuiObjectId(
        '0xd7d747343106d3586f9d96dce4741702de9033875b007f4a485f6593b2e53d79'
      ),
      initialSharedVersion: '384530230',
      mutable,
    }),
  } as const,
};

• ACL: Shared object holding the current whitelisted admins.

• VERSION: Shared object containing the latest version of the package.

• CONFIG: Shared object contain all different configurations:

  • Fees

  • Pump State

  • Stable State

  • Auction State

• MIGRATION_LIST: Shared object contain the allowed migrators.

Config Keys

The configuration supports various values per integrator. For example the fees for Recrd and Default keys will have different values. This is set by the admin.

export const CONFIG_KEYS = {
  [Network.Mainnet]: {
    DEFAULT: '',
    RECRD: ''
  },
  [Network.Testnet]: {
    DEFAULT: `${PACKAGES[Network.Testnet].MEMEZ_FUN}::memez_config::DefaultKey`,
    RECRD: `${PACKAGES[Network.Testnet].MEMEZ_WITNESS.original}::memez_witness::Recrd`,
  },
} as const;

• DEFAULT: This is key to get the default parameters.

• DEFAULT: To be used by RECRD.

Migrator Witnesses

Record of the current allowed migrators.

export const MIGRATOR_WITNESSES = {
  [Network.Mainnet]: {
    TEST: '',
  },
  [Network.Testnet]: {
    TEST: `${PACKAGES[Network.Testnet].MEMEZ_MIGRATOR}::dummy::Witness`,
  },
} as const;

• TEST: Currently we have a test migrator that returns the balances for testing purposes.

Memez.gg has a versatile fee mechanism enforced by the contracts. Each integrator is able to customize their fees parameters.

Fee Mechanism

Depending on the fee, it can be defined in basis points percentage or in a nominal value. The fees are collected by the stake holders depending on how the configuration is set.

Fees Configuration

Each fee below requires the following configuration:

• Fee Value

• Address of fee recipients

• Percentage that each recipient should receive in basis points.

If we set the Creation Fee to 2 Sui and the recipients to be the following: Alice (20%), Bob (50%) and Jose (30%).

At pool creation, the contract will automatically send 0.4 Sui to Alice, 1 Sui to Bob and 0.6 Sui to Jose. The system supports dynamic fee recipients at pool creation and system enforced ones as well. For example, we can set that 20% of the creation fee always goes to the integrator, while the rest of the fees recipients are set dynamically at pool creation.

• Creation: This fee is collected when a pool is created and it is defined in a nominal value. It is always charged in Sui.

• Swap: This fee is collected on every swap and is defined in percentage. It is taken both in Sui and the meme coin.

• Migration: This fee is charged in Sui from the liquidity being migrated in percentage.

• Allocation: This fee is charged in meme coin after migration in percentage.

Recrd Configuration

The Recrd fees configuration has 4 recipients and creation, swap, migration and allocation fees.

The other two recipients are set by the system. They are the Recrd and IPX treasury.

Nexa Configuration

The Nexa fees configuration has 2 system addresses to be charged on the migration and swap fee.

Nexa supports custom configuration option per pool. This means the caller can select the following parameters for their pump pools:

• Burn Tax (BPS)

• Virtual Liquidity

• Target Quote Liquidity

• Liquidity Provision (BPS)

Overview

Integrators can configure the following parameters:

• Burner tax

• Fees

• Pump Configuration

• Auction Configuration

• Stable Configuration

During creation, the deployer can choose which configuration the pool will adhere to. E.g., user A could opt for the Default configuration, while user B opts for another.

Burner

• Fee: A percentage in bps to determine how much amount to burn.

• Target Liquidity: The liquidity required t migrate the pool.

Example

Burner tar Tax Formula

progress = current_liquidity / target_liquidity

tax = burner_tax * progress Example

Let's assume we have a pool using the Pump strategy with a Sui Target Amount of 1_000 Sui and a Burner tax of 20% of 2_000 basis points.

t0: The pool has 0 Sui - burn tax would be 0%

Math:

progress = 0 / 1_000 ⇒ 0

20% * 0 / 1000 ⇒ 0%

t1: The pool has 800 Sui - burn tax would be 16%

Math:

progress = 800 / 1_000 ⇒ 80%

20% * 80% ⇒ 16%

Fees

Memez.fun has 3 fees:

• Creation: Sui amount charged to create a meme coin + pool.

• Swap: % charged on every sell or buy.

• Migration: Meme coin % to be used for DEX liquidity after migration.

• Allocation: Meme coin % allocated for the stake holders.

• Vesting Period: The duration of the linear vesting for the allocation.

The integrator can decide the total amount of each fee and the number of recipients per fee. It is possible to charge no fees at all and different percentages and recipients per fee. The swap and migration fee include the deployer as one of the recipients if chosen by the integrator.

For example an integrator can decide to have:

• Creation Fee of 2 Sui:

  • 20% to X

  • 60% to Y

  • 20% to Z

• No Swap fee

• 10 % Migration quote fee

  • 50% to A

  • 50% to B

• 5% Meme coin allocation to stake holders

Pump Configuration

The pump strategy has 4 configurable parameters:

• Burn Tax: The burner tax explained above

• Virtual Liquidity: The floor price of the Meme coin as determined by a virtual Sui amount

• Target Sui Liquidity: The amount of Sui the pool must collect to migrate. It can be seen as a target price.

• Liquidity Provision: Percentage of Meme coin to be used to seed the liquidity pool during migration.

• Quote Type: The type of the quote Coin<Quote>.

Auction Configuration

The pump strategy has 7 configurable parameters:

• Auction Duration: How long should the auction last.

• Target Quote Liquidity: The amount of Sui the pool must collect to migrate. It can be seen as a target price.

• Liquidity Provision: Percentage of Meme coin to be used to seed the liquidity pool during migration.

• Seed Liquidity: Percentage of meme coin that the pool should start with at the beginning of the auction.

• Quote Type: The type of the quote Coin<Quote>.

Stable Configuration

The pump strategy has 3 configurable parameters:

• Max Target Sui Liquidity: The maximum amount of liquidity the deployer can raise.

• Liquidity Provision: Percentage of Meme coin to be used to seed the liquidity pool during migration.

• Meme Sale Amount: Percentage of Meme coin to sell during the bonding phase.

• Quote Type: The type of the quote Coin<Quote>.

Move Dependencies

Interest BPS

It is an utility library to calculate percentages from values using basis points. It is referred as BPSin the code blocks.

IPX Coin Standard

It is an utility library designed to separate the capabilities of the treasury cap (mint/burn/update) to provide the owner more granular control.

Interest Math

A math library to safely perform operations.

Constant Product

A library that calculates the amount in and out of the constant product formula k = x * y

Problem

Coins created via Sui Network Coin have all the rights associated with one capability, the TreasuryCap.

The holder of the TreasuryCap can mint, burn and update the Coin. This design is quite limiting because all the rights are associated with a single capability.

What happens if a user wants to ensure that its coin can be burnt but not mintable? He would have to write its own contract.

Most users choose to simply send the TreasuryCap to the systems address, the famous 0x0, because no one has access to it. Therefore it is considered burnt. However, since no one has access to the TreasuryCap, no one can burn the coin nor update its icon, description, symbol or name. There are cases in which coins need to update its metadata due to a rebrand or broken uris.

Solution

The IPX Coin Standard separates the three rights of the TreasuryCap into three separate capabilities: Burn, Mint and Update metadata. This flexible design means that a user can make his/her coin burnable while preventing coins to be minted forever.

• MintCap allows the holder to mint coins

• BurnCap allows the holder to burn coins

• MetadataCap allows the holder to update the coin name, description, icon uri and symbol

Package Address: 0x7ead93e49fe002193faec3d2e4a7b750e9e568b5d875cafe17fcb0dc672b075e

Overview

Installation

SDK

How to setup the SDK.

Cetus

The Cetus migrator calls the function below to deploy a pool.

The Cetus protocol is initiated with the following parameters:

• Tick Spacing: 200.

  • Largest possible fee on Cetus.

• Initialized Price: 63901395939770060 or 0.000012 Sui.

• Tick Lower Index: 4294523696

• Tick Upper Index: 443600

  • This is to ensure full range liquidity

• Fix Amount A: true

  • The meme coin amount is fixed

We supply 5% of the total meme coin supply. E.g. If a coin has a supply of 1 billion, we add 50 million of value in coin_a. The Sui amount is configurable by the integrator.

Sandwich Attack Prevention

Interest Protocol protects users from sandwich attacks by introducing slot windows where the bid price remains constant during transactions. This innovative approach discourages malicious bots by making such attacks unprofitable.

Stable Curve

The protocol uses a hybrid bonding curve for correlated assets, combining:

• Constant Product Invariant: Ensures balanced liquidity.

• Constant Sum Invariant: Amplifies liquidity around the mid-range for optimal pricing.

Volatile Curve

For volatile assets, the platform tracks prices with an internal exponential moving average (EMA), concentrating liquidity around the current market price to enhance trading efficiency.

Hooks for Customization

Inspired by Uniswap V4, hooks enable deployers to customize pools with advanced features such as:

• Pre-swap/post-swap computations.

• Fee-on-swap models.

• Custom oracles or limit orders.

1. Token Swap

The Swap Tool allows users to exchange tokens directly in a simple and intuitive interface. With built-in protection against sandwich attacks, Interest Protocol ensures users can trade safely without the risk of bots exploiting their transactions.

Example: How to Swap Tokens

• Select the tokens you want to swap (e.g., MOVE → RUCO).

• Enter the desired amount and confirm the transaction.

• The DEX processes your swap securely with price stability thanks to its slot windows, which mitigate sandwich attacks.

Swap Tutorial

This feature ensures smooth transactions, even in volatile markets, with no extra steps required from the user.

2. Advanced Liquidity Management

Interest Protocol introduces a robust liquidity layer where projects and users can manage pools effortlessly. This feature supports both passive liquidity provision and innovative functionalities for liquidity providers (LPs):

• One-Sided Liquidity: LPs can provide liquidity with a single token, eliminating the need for equal-value pairs.

• Dynamic Liquidity Adjustment: The protocol automatically adjusts liquidity positions, reducing impermanent loss and enhancing fee capture for LPs.

• Multi-Coin Pools: Pools can include more than two assets, enabling creative and efficient trading pairs.

• LpCoins: Unlike traditional NFTs for liquidity, LpCoins are fungible, composable, and easily tradable, enhancing their usability within DeFi ecosystems.

3. Create and Launch Tokens

The Token Launcher is a powerful tool that allows anyone to create and launch new tokens without requiring coding skills. Along with token creation, users can seamlessly deploy liquidity pools to support their tokens.

Steps to Create and Launch a Token

2. Fill in token details:

   • Name, Symbol, Description, and upload a Logo.

3. Set the Total Supply.

4. Choose to deploy a liquidity pool during the creation process.

5. Specify the amount of liquidity to add for your token’s pool.

6. Confirm the transaction, and your token is live, backed by a liquidity pool.

This feature empowers developers and community members to bring new tokens to market efficiently and securely, fostering innovation in the DeFi space.

What is sandwich attacks and why should I care?

"Just let me ape" - everyday degenerate

AMMs are the primarly venue for meme coin trading and users tend to use high slippage to guarantee early entries. What most do not realize is that this exposes them to sandwich bots. This is a major issue that, for reference 50K Solana was essentially stolen in 1 month in 2024 due to this. The way is works is that Bots can see your transaction on the meme pool and simply place one to buy beforehand and another to sell right after. The first transaction increases the price, the user then purchases at a higher price increasing it further and then the bot sells at a profit.

Fine, what do I do?

Glad you ask, all you have to do is trade on Interest Protocol! Our AMM prevents most of the sandwich bot attacks by introducing slot windows in which the bid price is constant. In simpler terms, if a bot sandwiches you, it will lose money. There are no extra steps needed for the users, it is an invisible solution to the application layer.

Welcome to Interest Protocol DEX, a versatile decentralized exchange built on the Movement Network. The platform is designed for seamless trading, advanced liquidity management, and effortless token creation, all while incorporating cutting-edge security features to protect users from common exploits like sandwich attacks.

Get Started

2. Swap Tokens: Trade safely with built-in protections.

3. Manage Liquidity: Provide liquidity with ease using dynamic tools.

4. Create Tokens: Launch and deploy liquidity pools effortlessly.

Interest Protocol DEX is your gateway to secure, efficient, and innovative DeFi trading. Dive in today and explore its powerful tools to transform your crypto journey!

Constant Product

• k = constant

• x = Reserves of Coin X

• y = Reserves of Coin Y

This formula defines the pricing relationship between Coin X and Coin Y in a pool.

Pricing Function

X’ * Y’ = K

X’ = X + amountIn

Y’ = Y - amountOut

X * Y = (X + amountIn) * (Y - amountOut)

XY / (X + amountIn) = Y - amountOut

XY / (X + amountIn) - Y = -amountOut

XY / (X + amountIn) - Y (X + amountIn) / (X + amountIn) = - amountOut

- Y *amountIn / (X + amountIn) = - amountOut

We conclude that amountOut in Y is defined by

After every mutation, we ensure that the pool always maintains the invariant k = x * y by using the pricing formula above.

Virtual Liquidity

The use of virtual liquidity to create a floor price for the meme coin brings two benefits:

• Allows the token creator to start a market without supplying any Sui liquidity

• Prevents early buyers from getting too much supply.

Let us assume a pool of Meme/Sui. All pools on Memez.Fun use the Meme coin as the base coin and Sui as the quote coin. For example, let's imagine the absence of fees and first buy from the coin creator. If we would set up a pool with 1 billion coins of Meme and 0 Sui, we would break the invariant as k = 1e9 * 0.

This means that the pool would always be worth 0. To circumvent this issue, UniV2 forces the user to always supply both coins: the base coin and the quote coin. This is where virtual liquidity comes in, we can virtually set the pool with a floor price without requiring any investment from the token creator.

For example, We can set the virtual liquidity to be 1,000 Sui. If we assume that Sui is 5 dollars for simplicity sake, this means that at pool creation. The pool would be worth 10 thousand USD:

• 5 Thousand worth of Sui

• 5 Thousand worth of Meme

Assume we create Meme coin with 1e9 supply. 1 Meme coin would be worth 0.000001 Sui or ~$0.000005 (assuming Sui is $5).

Memez.Fun has a target Sui reserve that once it is achieved, the pool is migrated to a DEX.

Let's assume that we want the pool to migrate once the Meme achieves a market cap of $60,000.

Pool at start:

• Virtual Liquidity: 1,000 Sui

• Sui Reserves: 0

• Meme Reserves: 1e9

• Target Sui Reserve: 2,464 Sui

• Meme Coin price: 0.000001 Sui

• Target Meme Coin price: 0.000012 SUI

• Pool Value: $0

• Pool Virtual Value: $10,000

Target Meme Coin price explanation:

$60_000 / 1e9 Meme coin = $0.00006 per Meme

In Sui: $0.00006/$5 = 0.000012 SUI per Meme

0.000012 SUI per Meme Coin * 1e9 Meme Coin = 12,000 Sui ~ ($60,000)

How do we come up with a target Sui Reserve of 2,464 Sui?

• Target Price = 0.000012 Sui

• k = x * y = 1e12 (1e9 * 1000)

x * (0.000012x) = 1e12

0.000012x² = 1e12

x = sqrt(1e12/0.000012) ≈ 288,675,135 Meme tokens

Final y = 1e12/288,675,135 ≈ 3,464 Sui

Sui needed = 3,464 - 1,000 = 2,464 Sui

Conclusion: We would need a total of $12,321 (2,464 Sui) to migrate.

If we use the pricing formula above, we can see that it holds true:

(1e9 Meme * 2,464 Sui) / (1,000 Sui + 2,464 Sui) = 711,316,397 Meme

1e9 - 711,316,397 = 288,683,603

The pool would have 288,683,603 Meme and 3,464 Sui after a 2,464 Sui purchase. Using the price formula.

Price = y / x

3,464 Sui / 288,683,603 Meme ~ 0.000012

0.000012 * 1e9 = 12,000 Sui ($60,000)

Pool at the end:

• Virtual Liquidity: 1,000 Sui

• Sui Reserves: 2,464

• Meme Reserves: 288,683,603

• Target Sui Reserve: 2,464 Sui

• Meme Coin price: 0.000012 Sui

• Target Meme Coin price: 0.000012 Sui

• Pool Value: $12,320

• Pool Virtual Value: $17,320

Siloed Governance

Interest Protocol is MoveVM agnostic dApp, we provide secure DeFi in multiple chains. However, we do not believe in a shared/single governance coin. We want to silo the governance of each dApp by issuing one coin per chain. This guarantees that each token will reflect the performance of the dApp it is associated with. E.g. dApp on Sui will mint IPS (Interest Protocol Sui), while the dApp on Movement will mint IPM (Interest Protocol Movement).

Ve33 and Liquid Governance

IP holders have the full control of the issuance of the Coin. They decide on the minting rate per pool. This is done by locking up IP into veIP. At the time of lockup the holder allocates his/her voting power to a specific pool. The minting rate per pool is propertial to how much voting power they hold. It is imporant to note that voting power decays linearly over time and is valued at zero at the unlock day. This motivates project owners to accumulate voting power by buying IP Coins or bribing IP holders creating a sub economy around. In order to maintain the value of IP, 100% of the protocol fees are directed to the team. A percentage to burn IPCoin and the remaining to cover the team expenses.

This is code that is pending to change and is not longer recommended to be used in production.

Purpose

Coin X Oracle allows developers to easily deploy price oracles from various feeds without having to worry about each provider's intricacies and interfaces.

Upon requesting a price update, the Coin X Oracle will collect the price from various feeds and run a set of checks to make sure of its liveness and accuracy.

Flow

1. Request a price update

2. Collect the data from predetermined providers.

3. Run a set of checks to ensure the price accuracy and liveness.

Security

The entire process from the data request to reading it inside a DeFi dApp happens in one transaction block atomically through the use of hot potatoes. Price consumers have 100% confidence in the liveness and accuracy of the data.

Feeds

The following feeds are available:

DeFi has justly been criticized for its subpar security standards. Last year, we saw a 300 million USD hack on Solana wormhole. Security is a constant battle, and there is no single solution for it. We will always prioritize security over features or development speed.

We will employ the following security measures to fight hacks:

• 100% unit test coverage

• Formal verification tools once Move prover is updated

• Working MVP on a test-net before deployment

• Security audits before every deployment

• Upgradeable contracts to fix bugs post-deployment

• Bug bounties

• Secure oracles with backups

• Time locks to protect users from future changes

• Multi-signature wallets

We are Open-source

Open source platforms like Interest Protocol promote transparency and builds trust, encourages collaboration and innovation. We are accessible to users even those with limited resources. We feel secure because our vulnerabilities can be identified and fixed faster.

Advent

Journey through Movement testnet

• Movement Partner

• 150k+ Unique users

• 1 Million views (30 days)

• 1 Million TXs (30 days)

Expansion

Divide and conquer the mainnet

• Public Sale during MoveDrop

• CLAMM Mainnet Launch

• DeFi Incentives

• Audit and Restrospective Grants

MemeFi

Unleash the degeneracy

• sr-AMM launch

• memez.gg launch

Enlightenment

Unleash the degeneracy

• Liquidity Governance

• ve33 Gauges

Airdrop utils module contains the verify function to check if a Merkle proof combined with an address and amount are part of the Merkle tree root.

verify

Checks if the sender is allowed to redeem an amount from an airdrop using Merkle proofs. It returns the index of his Merkle proof to add to the Bitmap struct.

public fun verify(
    root: vector<u8>,
    proof: vector<vector<u8>>, 
    amount: u64, 
    sender: address
): u256

• @param root: The Merkle tree root that keeps track of all the airdrops.

• @param proof: The proof that the sender can redeem the amount from the airdrop.

• @param amount: The airdrop amount.

• @param sender: The address of the airdrop user.

• @return u256. An index.

Aborts

• if the leaf or proof are invalid.

The first price provider supported by Coin X Oracle is Pyth Network. It is the leading Oracle provider on Sui Network and the largest first-party Oracle Network in the world. It supports of over 50 chains and offers 450 price feeds.

First Party Institutional Providers

Pyth network data sources do not rely on intermediaries to ensure reliability and liveness of the data.

Price Confidence

Pyth Network is the only provider that offers a price confidence metric in all price feeds. Assets do not have a single price in a market at any given point in time. By providing a confidence range, DeFi dApps can design their invariant to take into account price variance.

Structs

struct PriceInfoObjectKey has copy, drop, store {}

A dynamic field key to store the sui::object::ID of the pyth::price_info::PriceInfoObject that can that provide data to the oracle.

struct ConfidenceKey has copy, drop, store {}

A dynamic field key to save the minimum required price confidence. It is a percentage, where 100% is represented by 1e18.

struct PythFeed has drop {}

A witness that is added to the suitears::oracle::Request to prove that it collected data from Coin X Oracle's Pyth Network module.

Functions

report

It requests a price from Pyth Network and submits the information to a Coin X oracle request.

public fun report<Witness: drop>(
    oracle: &Oracle<Witness>, 
    request: &mut Request, 
    wormhole_state: &WormholeState,
    pyth_state: &PythState,
    buf: vector<u8>,
    price_info_object: &mut PriceInfoObject,
    pyth_fee: Coin<SUI>,
    clock_object: &Clock
 )

• @param self. A suiterars::oracle::Oracle with this module's witness.

• @param request. A hot potato issued from the self to create a suiterars::oracle::Price.

• @param wormhole_state. The state of the Wormhole module on Sui.

• @param pyth_state. The state of the Pyth module on Sui.

• @param buf. Price attestations in bytes.

• @param price_info_object. An object that contains price information. One per asset.

• @param pyth_fee. There is a cost to request a price update from Pyth.

• @param clock_object. The shared Clock object from Sui

Aborts

• the price_info_object is not whitelisted.

• the price confidence is out of range.

• the price is negative or zero.

Structs

Airdrop

struct Airdrop<phantom T> has key, store { 
    id: UID,
    balance: Balance<T>,
    root: vector<u8>,
    start: u64, 
    map: Bitmap
}

• balance - Coins to airdrop

• root - The root of the Merkle tree

• start - The timestamp in which users can claim the airdrop

• map - Bitmap keeps track of airdrop claims.

Interface

new

It creates the Airdrop object.

public fun new(airdrop_coin: Coin<T>, root: vector<u8>, start: u64, c: &Clock, ctx: &mut TxContext): Airdrop<T>

• @param airdrop_coin: The coin that will be distributed in the airdrop.

• @param root: The Merkle tree root that keeps track of all the airdrops.

• @param start: The start timestamp of the airdrop in milliseconds.

• @param c: The sui::clock::Clock shared object.

• @return Airdrop<T>

Aborts

• root is empty.

• start time of the airdrop is in the past.

balance

Returns the current amount of airdrop coins in the Airdrop object.

public fun balance<T>(self: &Airdrop<T>): u64

• @param: self The shared Airdrop object

• @return u64