Creating a Coin

This guide covers how to create coins directly using the Basememe Factory contract.

Basememe Factory contract creates Coins, setting up Bonding Curves and initializing Uniswap pools. Coins created before December 5, 2025 are configured to use Uniswap V3 pools, while coins created on or after December 5, 2025 are using Uniswap V4 pools. Each Coin is configured to have a Bonding Curve and a Liquidity pool setup with a coin pair of its backing currency on each chain.

Create Coin

To create a new coin with selected collateral pair, you send a transaction to call the createBasememeTokenWithCollateral method.

You may create token with following collateral:

Collateral Pair	Address
ETH	0x0000000000000000000000000000000000000000
USDC	0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
SOL	0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82

Method Interface

// solidity interface 

/// @notice Create a new token with required params
///
/// @param _name The name of the token
/// @param _symbol The symbol/ticker of the token
/// @param _tokenURI The IPFS URI of token metadata
/// @param _nonce Random number for salt generation
/// @param _signature The verify-able signature for token creation
/// @param _platformReferrer The Creator Referrer address to receive reward
/// @param _payoutRecipient The Creator address to receive reward
/// @param _tokenSalt Salt for deterministic CREATE2 deployment. Enables predictable token addresses.
/// @param _collateralToken Selected collateral pair for created token
///
/// @return token The address of the created token
function createBasememeTokenWithCollateral(
    string memory _name,
    string memory _symbol,
    string memory _tokenURI,
    uint256 _nonce,
    bytes memory _signature,
    address _platformReferrer,
    address _payoutRecipient,
    bytes32 _tokenSalt,
    address _collateralToken
) 
    external 
    returns (address);

Events

The factory emit an event upon successful coin creation

In addition, a NewBasememeTokenCurveParams event is emitted at creation time to publish the token's economic parameters, including the selected collateralToken and v4LpFee.

/// @notice emitted when a new token is created
///
/// @param addr The token contract address
/// @param bondingCurve The Bonding Curve address of the token
/// @param creator The sender address of token creation
/// @param signature The signature used to create the token
/// @param platformReferrer The Creator Referrer address to receive reward
/// @param payoutReceipent The Creator address to receive reward
/// @param owner The owner address of token contract
/// @param nonce Random number for salt generation
/// @param name The name of the token
/// @param symbol The symbol/ticker of the token
/// @param tokenURI The IPFS URI of token metadata
/// @param version The BasememeToken version created
event NewBasememeToken(
    address addr,
    address bondingCurve,
    address creator, 
    bytes signature, 
    address platformReferrer, 
    address payoutRecipient, 
    address owner,
    uint256 nonce,
    string name,
    string symbol,
    string tokenURI,
    string version      
);

---

Create and Buy Coin

To create and buy a new coin with a selected collateral pair, you send a transaction to call the createBasememeTokenAndBuyWithCollateral method.

You may create token with following collateral:

Collateral Pair	Address
ETH	0x0000000000000000000000000000000000000000
USDC	0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913
SOL	0x311935Cd80B76769bF2ecC9D8Ab7635b2139cf82

Method Interface

// solidity interface 

/// @notice Create a new token and buy upon creation with required params
///
/// @param _name The name of the token
/// @param _symbol The symbol/ticker of the token
/// @param _tokenURI The IPFS URI of token metadata
/// @param _nonce Random number for salt generation
/// @param _collateralAmountIn The exact amount of collateral to spend (before fees)
/// @param _tokenAmountMin Min expected amount of token to receive
/// @param _signature The verify-able signature for token creation
/// @param _platformReferrer The Creator Referrer address to receive reward
/// @param _payoutRecipient The Creator address to receive reward
/// @param _tokenSalt Salt for deterministic CREATE2 deployment. Enables predictable token addresses.
/// @param _collateralToken Selected collateral pair for created token
///
/// @return token The address of the created token
function createBasememeTokenAndBuyWithCollateral(
    string memory _name,
    string memory _symbol,
    string memory _tokenURI,
    uint256 _nonce,
    uint256 _collateralAmountIn,
    uint256 _tokenAmountMin,
    bytes memory _signature,
    address _platformReferrer,
    address _payoutRecipient,
    bytes32 _tokenSalt,
    address _collateralToken
)
    external
    payable
    returns (address);

Payment notes

• If _collateralToken is ETH (address(0)), send msg.value == _collateralAmountIn.

• If _collateralToken is an ERC20 collateral token (e.g. USDC / SOL), msg.value must be 0 and the caller must approve the Factory to spend _collateralAmountIn of the collateral token.

Events

The factory emit NewBasememeToken event upon successful coin creation

In addition, a NewBasememeTokenCurveParams event is emitted at creation time to publish the token's economic parameters, including the selected collateralToken and v4LpFee.

/// @notice emitted when a new token is created
///
/// @param addr The token contract address
/// @param bondingCurve The Bonding Curve address of the token
/// @param creator The sender address of token creation
/// @param signature The signature used to create the token
/// @param platformReferrer The Creator Referrer address to receive reward
/// @param payoutReceipent The Creator address to receive reward
/// @param owner The owner address of token contract
/// @param nonce Random number for salt generation
/// @param name The name of the token
/// @param symbol The symbol/ticker of the token
/// @param tokenURI The IPFS URI of token metadata
/// @param version The BasememeToken version created
event NewBasememeToken(
    address addr,
    address bondingCurve,
    address creator, 
    bytes signature, 
    address platformReferrer, 
    address payoutRecipient, 
    address owner,
    uint256 nonce,
    string name,
    string symbol,
    string tokenURI,
    string version      
);

Successful purchase of new coin create will emit Buy event

/// @notice emitted upon successful token purchase
///
/// @param buyer The token buyer address
/// @param token The purchased token address
/// @param tokenAmount The amount of token purhased
/// @param collateralAmount The amount of collateral used to purchase token (depends on the coin's selected collateral pair)
/// @param refund The amount of collateral refunded to buyer if there's leftover
/// @param tradeFee The amount of fee collected by platform for token purchase
/// @param curveProgressBps The updated Bonding Curve progress basis points for token
/// @param virtualCollateralReserves The updated virtual collateral reserves amount in Bonding Curve stage
/// @param virtualTokenReserves The updated virtual token reserves amount in Bonding Curve stage
/// @param collateralReserves The updated real collateral reserves amount in Bonding Curve stage
/// @param tokenReserves The updated real token reserves amount in Bonding Curve stage
event Buy(
    address indexed buyer,
    address indexed token,
    uint256 tokenAmount,
    uint256 collateralAmount,
    uint256 refund,
    uint256 tradeFee,
    uint256 curveProgressBps,
    uint256 virtualCollateralReserves,
    uint256 virtualTokenReserves,
    uint256 collateralReserves,
    uint256 tokenReserves
);

---

Create Coin (Advanced Mode)

Advanced mode lets creators customize the coin’s funding target and token allocation at creation time. To create an advanced-mode coin with a selected collateral pair, call createBasememeTokenDynamicWithCollateral.

Method Interface

/// @notice Create a new token using advanced parameters (dynamic-create) and a selected collateral pair.
///
/// @param targetRaise The funding target (in the selected collateral token's units).
function createBasememeTokenDynamicWithCollateral(
    string memory _name,
    string memory _symbol,
    string memory _tokenURI,
    uint256 _nonce,
    bytes memory _signature,
    address _platformReferrer,
    address _payoutRecipient,
    bytes32 _tokenSalt,
    address _collateralToken,
    uint256 targetRaise
)
    external
    returns (address);

Advanced mode also supports an optional vesting allocation via an additional overload:

/// @notice Create a new token using advanced parameters (dynamic-create) with an optional vesting allocation.
///
/// @param lockBps Vesting allocation in basis points (bps).
/// @param lockupDuration Lockup duration in seconds.
/// @param vestingDuration Vesting duration in seconds.
/// @param lockAdmin The admin address for the vesting schedule.
function createBasememeTokenDynamicWithCollateral(
    string memory _name,
    string memory _symbol,
    string memory _tokenURI,
    uint256 _nonce,
    bytes memory _signature,
    address _platformReferrer,
    address _payoutRecipient,
    bytes32 _tokenSalt,
    address _collateralToken,
    uint256 targetRaise,
    uint16 lockBps,
    uint64 lockupDuration,
    uint64 vestingDuration,
    address lockAdmin
)
    external
    returns (address);

Events

In addition to NewBasememeToken and NewBasememeTokenCurveParams, advanced-mode creation emits NewBasememeTokenDynamicParams to publish the selected/derived advanced parameters for indexers and integrators.

/// @notice Emitted when an advanced-mode token is created, including derived parameters.
event NewBasememeTokenDynamicParams(
    address indexed addr,
    address indexed bondingCurve,
    bytes32 indexed profileId,
    uint256 targetRaise,
    uint16 sellBps,
    uint256 lockAmount,
    uint256 virtualTokenReservesInitial,
    uint256 virtualCollateralReservesInitial,
    uint256 endPriceNum,
    uint256 endPriceDen,
    int24 upperBelow,
    int24 lowerAbove,
    int24 lowBelowTick,
    uint256 pairedToMigrateMin
);

---

Create Coin (ETH Pair only)

To create a new coin that is paired with ETH only, you send a transaction to call the createBasememeToken method. For USDC / SOL collateral pairs, use createBasememeTokenWithCollateral instead.

Method Interface

// solidity interface 

/// @notice Create a new token with required params
///
/// @param _name The name of the token
/// @param _symbol The symbol/ticker of the token
/// @param _tokenURI The IPFS URI of token metadata
/// @param _nonce Random number for salt generation
/// @param _signature The verify-able signature for token creation
/// @param _platformReferrer The Creator Referrer address to receive reward
/// @param _payoutRecipient The Creator address to receive reward
/// @param _tokenSalt Salt for deterministic CREATE2 deployment. Enables predictable token addresses.
///
/// @return token The address of the created token
function createBasememeToken(
    string memory _name,
    string memory _symbol,
    string memory _tokenURI,
    uint256 _nonce,
    bytes memory _signature,
    address _platformReferrer,
    address _payoutRecipient,
    bytes32 _tokenSalt
)
    external
    returns (address);

Events

The factory emit an event upon successful coin creation

/// @notice emitted when a new token is created
///
/// @param addr The token contract address
/// @param bondingCurve The Bonding Curve address of the token
/// @param creator The sender address of token creation
/// @param signature The signature used to create the token
/// @param platformReferrer The Creator Referrer address to receive reward
/// @param payoutReceipent The Creator address to receive reward
/// @param owner The owner address of token contract
/// @param nonce Random number for salt generation
/// @param name The name of the token
/// @param symbol The symbol/ticker of the token
/// @param tokenURI The IPFS URI of token metadata
/// @param version The BasememeToken version created
event NewBasememeToken(
    address addr,
    address bondingCurve,
    address creator, 
    bytes signature, 
    address platformReferrer, 
    address payoutRecipient, 
    address owner,
    uint256 nonce,
    string name,
    string symbol,
    string tokenURI,
    string version      
);

---

Create and Buy Coin (ETH Pair only)

To create and buy a new coin that is paired with ETH only, you send a transaction to call the createBasememeTokenAndBuy method. For USDC / SOL collateral pairs, use createBasememeTokenAndBuyWithCollateral instead.

Method Interface

// solidity interface 

/// @notice Create a new token and buy upon creation with required params
///
/// @param _name The name of the token
/// @param _symbol The symbol/ticker of the token
/// @param _tokenURI The IPFS URI of token metadata
/// @param _nonce Random number for salt generation
/// @param _tokenAmountMin Min expected amount of token to receive
/// @param _signature The verify-able signature for token creation
/// @param _platformReferrer The Creator Referrer address to receive reward
/// @param _payoutRecipient The Creator address to receive reward
/// @param _tokenSalt Salt for deterministic CREATE2 deployment. Enables predictable token addresses.
///
/// @return token The address of the created token
function createBasememeTokenAndBuy(
    string memory _name,
    string memory _symbol,
    string memory _tokenURI,
    uint256 _nonce,
    uint256 _tokenAmountMin,
    bytes memory _signature,
    address _platformReferrer,
    address _payoutRecipient,
    bytes32 _tokenSalt
)
    external
    payable
    returns (address);

Events

The factory emit NewBasememeToken event upon successful coin creation

/// @notice emitted when a new token is created
///
/// @param addr The token contract address
/// @param bondingCurve The Bonding Curve address of the token
/// @param creator The sender address of token creation
/// @param signature The signature used to create the token
/// @param platformReferrer The Creator Referrer address to receive reward
/// @param payoutReceipent The Creator address to receive reward
/// @param owner The owner address of token contract
/// @param nonce Random number for salt generation
/// @param name The name of the token
/// @param symbol The symbol/ticker of the token
/// @param tokenURI The IPFS URI of token metadata
/// @param version The BasememeToken version created
event NewBasememeToken(
    address addr,
    address bondingCurve,
    address creator, 
    bytes signature, 
    address platformReferrer, 
    address payoutRecipient, 
    address owner,
    uint256 nonce,
    string name,
    string symbol,
    string tokenURI,
    string version      
);

Successful purchase of new coin create will emit Buy event

/// @notice emitted upon successful token purchase
///
/// @param buyer The token buyer address
/// @param token The purchased token address
/// @param tokenAmount The amount of token purhased
/// @param collateralAmount The amount of collateral used to purchase token (depends on the coin's selected collateral pair)
/// @param refund The amount of collateral refunded to buyer if there's leftover
/// @param tradeFee The amount of fee collected by platform for token purchase
/// @param curveProgressBps The updated Bonding Curve progress basis points for token
/// @param virtualCollateralReserves The updated virtual collateral reserves amount in Bonding Curve stage
/// @param virtualTokenReserves The updated virtual token reserves amount in Bonding Curve stage
/// @param collateralReserves The updated real collateral reserves amount in Bonding Curve stage
/// @param tokenReserves The updated real token reserves amount in Bonding Curve stage
event Buy(
    address indexed buyer,
    address indexed token,
    uint256 tokenAmount,
    uint256 collateralAmount,
    uint256 refund,
    uint256 tradeFee,
    uint256 curveProgressBps,
    uint256 virtualCollateralReserves,
    uint256 virtualTokenReserves,
    uint256 collateralReserves,
    uint256 tokenReserves
);

Additional Info

There're 2 params in both create token method that need extra attention:

• _tokenURI : All the metadata about created coins are stored on IPFS. You need to upload your image and the meta of your token to IPFS following example below:

{
    name: "My Base Memecoin",
    description: "Base for everyone!",
    symbol: "MYBASECOIN",
    image: "ipfs://CID/base_coin.png",
    website: "https://example.com",
    x: "https://x.com/my_base_coin",
    telegram: "https://t.me/my_base_coin",
}

• _signature : For the moment, there's no signature required to create a coin using Basememe Factory, pass in empty bytes value for _signature will do the job.