Deposit

Adds liquidity to a pool on the CoolDEX.

Instruction

DepositInstruction {
    max_coin_amount: u64,
    max_pc_amount: u64,
    base_side: u64,
    other_amount_min: Option<u64>,
}

Parameters

Parameter	Type	Description
max_coin_amount	u64	Maximum amount of coin token to deposit
max_pc_amount	u64	Maximum amount of PC token to deposit
base_side	u64	Indicates which token is the base for the deposit (0 for coin, 1 for PC)
other_amount_min	Option<u64>	Minimum acceptable amount of the other token (slippage protection)

Account Setup

#	Account	Description	Derivation
1	Token program	SPL Token program	TOKEN_PROGRAM_ID
2	AMM info	AMM account	[program.toBuffer(), marketId.toBuffer(), "amm_associated_seed"]
3	AMM authority	AMM authority PDA	[Buffer.from("amm authority")]
4	AMM LP mint	LP token mint	[program.toBuffer(), marketId.toBuffer(), "lp_mint_associated_seed"]
5	AMM coin vault	Token vault	[program.toBuffer(), marketId.toBuffer(), "coin_vault_associated_seed"]
6	AMM PC vault	SOL vault	[program.toBuffer(), marketId.toBuffer(), "pc_vault_associated_seed"]
7	User source coin	User's token account	getAssociatedTokenAddress(tokenMint, userWallet, false)
8	User source PC	User's SOL account	getAssociatedTokenAddress(NATIVE_MINT, userWallet, false)
9	User dest LP	User's LP token account	getAssociatedTokenAddress(lpMint, userWallet, false)
10	Source owner	Transaction signer (User wallet)	-

Function Logic

1. Verifies the transaction is signed by the source owner

2. Checks that the AMM is in a valid state for deposits

3. Verifies that the deposit amounts are not zero

4. Calculates the deposit amounts based on the current pool ratio:

   • If base_side is 0 (coin): Calculates PC amount based on provided coin amount

   • If base_side is 1 (PC): Calculates coin amount based on provided PC amount

5. Verifies amounts are within specified limits and match minimum requirements

6. Calculates LP tokens to mint based on the proportion of assets being added

7. Transfers coin and PC tokens from user to respective vaults

8. Mints LP tokens to the user

9. Updates the AMM's LP token supply

LP Token Calculation

The amount of LP tokens minted is calculated using the proportion of assets being added to the pool:

For base_side = 0 (coin base):

mint_lp_amount = (deduct_coin_amount / total_coin_without_take_pnl) * amm.lp_amount

For base_side = 1 (PC base):

mint_lp_amount = (deduct_pc_amount / total_pc_without_take_pnl) * amm.lp_amount

Where:

• total_coin_without_take_pnl is the total coin amount in the pool

• total_pc_without_take_pnl is the total PC amount in the pool

• amm.lp_amount is the current total supply of LP tokens

Notes

• Deposits must maintain the current ratio of assets in the pool

• Using base_side allows specifying which token amount is fixed

• The other token amount is calculated to maintain the pool ratio

• LP tokens represent a proportional share of the pool

• Slippage protection can be used to set minimum acceptable amounts

Example Usage

// Derive AMM accounts (similar to swap example)
const [ammAuthority] = PublicKey.findProgramAddressSync(
  [Buffer.from("amm authority")],
  COOLDEX_PROGRAM_ID
)

const [ammId] = PublicKey.findProgramAddressSync(
  [
    COOLDEX_PROGRAM_ID.toBuffer(),
    marketId.toBuffer(),
    Buffer.from("amm_associated_seed"),
  ],
  COOLDEX_PROGRAM_ID
)

const [lpMint] = PublicKey.findProgramAddressSync(
  [
    COOLDEX_PROGRAM_ID.toBuffer(),
    marketId.toBuffer(),
    Buffer.from("lp_mint_associated_seed"),
  ],
  COOLDEX_PROGRAM_ID
)

const [ammCoinVault] = PublicKey.findProgramAddressSync(
  [
    COOLDEX_PROGRAM_ID.toBuffer(),
    marketId.toBuffer(),
    Buffer.from("coin_vault_associated_seed"),
  ],
  COOLDEX_PROGRAM_ID
)

const [ammPcVault] = PublicKey.findProgramAddressSync(
  [
    COOLDEX_PROGRAM_ID.toBuffer(),
    marketId.toBuffer(),
    Buffer.from("pc_vault_associated_seed"),
  ],
  COOLDEX_PROGRAM_ID
)

// User token accounts
const userTokenAccount = getAssociatedTokenAddressSync(tokenMint, wallet.publicKey, false)

const userWsolAccount = getAssociatedTokenAddressSync(
  NATIVE_MINT,
  wallet.publicKey,
  false
)

const userLpAccount = getAssociatedTokenAddressSync(lpMint, wallet.publicKey, false)

// Create instruction data
const data = Buffer.alloc(25)
data.writeUInt8(3, 0) // Deposit instruction
data.writeBigUInt64LE(maxCoinAmount, 1) // Max coin amount
data.writeBigUInt64LE(maxPcAmount, 9) // Max PC amount
data.writeBigUInt64LE(baseSide, 17) // Base side (0=coin, 1=PC)
// Include otherAmountMin if provided

const depositIx = new TransactionInstruction({
  programId: COOLDEX_PROGRAM_ID,
  keys: [
    { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
    { pubkey: ammId, isSigner: false, isWritable: true },
    { pubkey: ammAuthority, isSigner: false, isWritable: false },
    { pubkey: lpMint, isSigner: false, isWritable: true },
    { pubkey: ammCoinVault, isSigner: false, isWritable: true },
    { pubkey: ammPcVault, isSigner: false, isWritable: true },
    { pubkey: userTokenAccount, isSigner: false, isWritable: true },
    { pubkey: userWsolAccount, isSigner: false, isWritable: true },
    { pubkey: userLpAccount, isSigner: false, isWritable: true },
    { pubkey: wallet.publicKey, isSigner: true, isWritable: false },
  ],
  data: data,
})