Conviction Pool Management

Creating Conviction Pool

1. Set During Token Creation

// Create conviction pool simultaneously when creating token
const createParams = {
  insurance_amt: 1000000000, // Conviction amount (lamports)
  insurance_px: 500000000, // Trigger price (lamports)
  name: "My Token",
  symbol: "MTK",
  uri: "ipfs://metadata_hash",
  user_pubkey: "user_wallet_public_key",
  network: "mainnet",
  platform: "meteora",
};

2. Create Conviction Pool Separately

// Create Conviction pool for existing token
const convictionParams = {
  mint: "token_address",
  insuranceAmt: 1000000000, // Conviction amount
  insurancePx: 500000000, // Trigger price
  userPubkey: "user_address",
};

// Call on-chain Conviction pool initialization
const convictionIx = await program.methods
  .initInsurance({
    amt: new BN(insuranceParams.insuranceAmt),
    startPrice: new BN(insuranceParams.insurancePx),
    creator: userPublicKey,
    mint: mintPubkey,
    name: tokenName,
    symbol: tokenSymbol,
    uri: "",
    poolId,
  })
  .instruction();

Query Conviction Pool Information

Endpoint: POST /api/token/conviction_pool/{token_address}

Request Headers:

Authorization: Bearer your_jwt_token
Content-Type: application/json

Response Example:

{
  "code": 200,
  "data": {
    "token_address": "token_address",
    "creator": "creator_address",
    "insurance_amt": 1000000000,
    "insurance_activation_price": 500000000,
    "insurance_status": "reserved",
    "has_deployed_insurance": true,
    "can_redeem_insurance": false,
    "deposit_time": "2024-01-01T00:00:00Z",
    "activation_time": null,
    "refund_time": null
  }
}

Conviction Pool Status

Status Types

• reserved: Reserved, not triggered

• deployed: Triggered, tokens swapped

• redeemed: SOL redeemed

Status Determination Logic

// Calculate Conviction pool status
const computeInsuranceStatus = (token) => {
  if (!token.has_deployed_insurance) {
    return "none";
  }

  if (token.can_redeem_insurance) {
    return "redeemable";
  }

  if (token.insurance_status === "deployed") {
    return "deployed";
  }

  return "reserved";
};

Redeem Conviction Pool

Redemption Conditions

• Token price has not fallen below protection price

• Beyond lock period (usually a few days)

• User is the conviction pool creator

Redemption Process

// Check redemption conditions
if (!tokenData.can_redeem_insurance) {
  throw new Error("Redemption conditions not met");
}

// Call redemption function
const refundParams = {
  mint: tokenAddress,
  userPubkey: userAddress,
};

const signature = await refundInsurance(connection, refundParams, wallet);

On-chain Redemption Transaction

// Build redemption transaction
const refundIx = await program.methods
  .refundInsurance()
  .accounts({
    dish: dishPDA,
    insuranceVault: insuranceVaultPDA,
    user: userPublicKey,
    systemProgram: SystemProgram.programId,
  })
  .instruction();

Conviction Pool Trigger Mechanism

Auto-trigger Conditions

• Current token price ≤ set protection price

• Meets minimum trigger time interval

• Pool has sufficient liquidity

Post-trigger Processing

• Automatically swap tokens for SOL

• Update conviction pool status to "deployed"

• User can no longer redeem original SOL

Time Lock Mechanism

Lock Period Calculation

// Check if redemption is possible (time lock)
const canRedeem = (depositTime, currentTime) => {
  const lockPeriod = 3 * 24 * 60 * 60 * 1000; // 3 days
  return currentTime - depositTime > lockPeriod;
};

Countdown Display

// Calculate remaining lock time
const getRemainingTime = (depositTime) => {
  const lockPeriod = 3 * 24 * 60 * 60 * 1000;
  const elapsed = Date.now() - depositTime;
  const remaining = Math.max(0, lockPeriod - elapsed);

  return {
    days: Math.floor(remaining / (24 * 60 * 60 * 1000)),
    hours: Math.floor((remaining % (24 * 60 * 60 * 1000)) / (60 * 60 * 1000)),
    minutes: Math.floor((remaining % (60 * 60 * 1000)) / (60 * 1000)),
    seconds: Math.floor((remaining % (60 * 1000)) / 1000),
  };
};

Key Points

• Conviction pool requires locking real SOL

• Protection price setting needs to be careful, too high easily triggers

• Time lock mechanism prevents frequent operations

• Cannot be reversed after triggering, SOL will be swapped

• Supports querying historical conviction pool records

• Each token can only have one conviction pool