L'Extension Interest Bearing

L'extension interest_bearing (Porteur d'Intérêts) est une extension de compte de Mint qui permet aux utilisateurs d'appliquer un taux d'intérêt à leurs jetons et de récupérer le total mis à jour, intérêts compris, à tout moment.

Initialisation du Compte de Mint

Comme Anchor ne possède aucune macro pour l'extension interest_bearing nous allons créer un compte de Mint à l'aide de CPIs bruts.

Voici comment créer un compte de mint avec l'extension interest_bearing :

rust
use anchor_lang::prelude::*;
use anchor_lang::system_program::{create_account, CreateAccount};
use anchor_spl::{
    token_2022::{
        initialize_mint2,
        spl_token_2022::{extension::ExtensionType, pod::PodMint},
        InitializeMint2,
    },
    token_interface::{
        interest_bearing_mint_initialize, InterestBearingMintInitialize, Mint, Token2022,
    },
};
 
#[derive(Accounts)]
pub struct Initialize<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,
    #[account(mut)]
    pub mint_account: Signer<'info>,
    pub token_program: Program<'info, Token2022>,
    pub system_program: Program<'info, System>,
}
 
pub fn initialize_interest_bearing_config(
    ctx: Context<Initialize>,
    rate: i16
) -> Result<()> {
    // Calculate space required for mint and extension data
    let mint_size =
        ExtensionType::try_calculate_account_len::<PodMint>(&[ExtensionType::InterestBearingConfig])?;
 
    // Calculate minimum lamports required for size of mint account with extensions
    let lamports = (Rent::get()?).minimum_balance(mint_size);
 
    // Invoke System Program to create new account with space for mint and extension data
    create_account(
        CpiContext::new(
            ctx.accounts.system_program.to_account_info(),
            CreateAccount {
                from: ctx.accounts.payer.to_account_info(),
                to: ctx.accounts.mint_account.to_account_info(),
            },
        ),
        lamports,                          // Lamports
        mint_size as u64,                  // Space
        &ctx.accounts.token_program.key(), // Owner Program
    )?;
 
    // Initialize the InterestBearingConfig extension
    // This instruction must come before the instruction to initialize the mint data
    interest_bearing_mint_initialize(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            InterestBearingMintInitialize {
                token_program_id: ctx.accounts.token_program.to_account_info(),
                mint: ctx.accounts.mint_account.to_account_info(),
            },
        ),
        Some(ctx.accounts.payer.key()),
        rate,
    )?;
 
    // Initialize the standard mint account data
    initialize_mint2(
        CpiContext::new(
            ctx.accounts.token_program.to_account_info(),
            InitializeMint2 {
                mint: ctx.accounts.mint_account.to_account_info(),
            },
        ),
        2,                               // decimals
        &ctx.accounts.payer.key(),       // mint authority
        Some(&ctx.accounts.payer.key()), // freeze authority
    )?;
 
    Ok(())
}

Calcul des Intérêts

L'extension InterestBearing ne génère pas de nouveaux jetons. Le montant affiché inclut simplement les intérêts cumulés via la fonction amount_to_ui_amount, ce qui rend le changement purement esthétique.

Ainsi, après avoir unpacking ("déballé") le compte de Token dont nous voulons calculer les intérêts, il est facile d'obtenir toutes les informations dont nous avons besoin pour calculer le montant des intérêts.

Heureusement pour nous, nous n'avons même pas besoin de le faire, car nous pouvons utiliser la fonction amountToUiAmount comme ceci :

ts
const tokenInfo = await getAccount(
    connection,
    tokenAccount,
    undefined,
    TOKEN_2022_PROGRAM_ID,
);
 
console.log("Token Amount: ", tokenInfo.amount);
    
const uiAmount = await amountToUiAmount(
    connection,
    keypair,
    mint.publicKey,
    tokenInfo.amount,
    TOKEN_2022_PROGRAM_ID,
);
    
console.log("UI Amount: ", uiAmount);

Mettre à Jour l'Extension Interest Bearing

Avec l'extension InterestBearing, il est possible de modifier les intérêts générés par le Compte de Jeton grâce à la manière dont ses données sont structurées :

rust
pub struct InterestBearing {
    pub rate_authority: Pubkey,
    pub initialization_timestamp: i64,
    pub pre_update_average_rate: u16,
    pub last_update_timestamp: i64,
    pub current_rate: u16,
}

Pour cela, nous pouvons utiliser la fonction updateRateInterestBearingMint comme ci :

ts
const updateRateInstruction = await createUpdateRateInterestBearingMintInstruction(
    mint.publicKey,
    newRateAuthority.publicKey,
    1000, // updated rate
    undefined,
    TOKEN_2022_PROGRAM_ID,
);

Et si nous le souhaitons, nous pouvons modifier l'autorité chargée de définir les intérêts à l'aide de la fonction setAuthority en spécifiant le bon AuthorityType comme ci :

ts
const setAuthorityInstruction = await createSetAuthorityInstruction(
    mint.publicKey,
    keypair.publicKey,
    AuthorityType.InterestRate,
    newRateAuthority.publicKey,
    [],
    TOKEN_2022_PROGRAM_ID,
);

Token2022 avec Anchor

L'Extension Interest Bearing

Initialisation du Compte de Mint

Calcul des Intérêts

Mettre à Jour l'Extension Interest Bearing