fix[l-01]: allow partial rent debt repayment (#76)

Signed-off-by: Reinis Martinsons <reinis@umaproject.org>

Author: Reinis-FRP

programs/sponsored-cctp-src-periphery/src/error.rs

@@ -34,8 +34,6 @@ pub enum SvmError {
     MissingRentClaimAccount,
     #[msg("Rent claim amount overflow")]
     RentClaimOverflow,
-    #[msg("Insufficient rent fund balance")]
-    InsufficientRentFundBalance,
     #[msg("Invalid recipient key")]
     InvalidRecipientKey,
 }

programs/sponsored-cctp-src-periphery/src/event.rs

@@ -57,4 +57,5 @@ pub struct AccruedRentFundLiability {
 pub struct RepaidRentFundDebt {
     pub user: Pubkey,
     pub amount: u64,
+    pub remaining_user_claim: u64,
 }

programs/sponsored-cctp-src-periphery/src/instructions/deposit.rs

@@ -186,6 +186,13 @@ pub fn deposit_for_burn(mut ctx: Context<DepositForBurn>, params: &DepositForBur
 
     emit_cpi!(CreatedEventAccount { message_sent_event_data: ctx.accounts.message_sent_event_data.key() });
 
+    // Close the claim account if the user passed Some rent_claim account without accruing any rent_fund debt.
+    if let Some(rent_claim) = &ctx.accounts.rent_claim {
+        if rent_claim.amount == 0 {
+            rent_claim.close(ctx.accounts.signer.to_account_info())?;
+        }
+    }
+
     Ok(())
 }
 

programs/sponsored-cctp-src-periphery/src/instructions/maintenance.rs

@@ -19,12 +19,7 @@ pub struct RepayRentFundDebt<'info> {
     #[account(mut)]
     pub recipient: UncheckedAccount<'info>,
 
-    #[account(
-        mut,
-        close = recipient,
-        seeds = [b"rent_claim", recipient.key().as_ref()],
-        bump
-    )]
+    #[account(mut, seeds = [b"rent_claim", recipient.key().as_ref()], bump)]
     pub rent_claim: Account<'info, RentClaim>,
 
     pub system_program: Program<'info, System>,
@@ -33,21 +28,18 @@ pub struct RepayRentFundDebt<'info> {
 pub fn repay_rent_fund_debt(ctx: Context<RepayRentFundDebt>) -> Result<()> {
     let anchor_rent = Rent::get()?;
 
-    // Debt amount might be zero if user had passed Some rent_claim account without accruing any rent_fund debt in the
-    // deposit. Exit early in this case so that rent_claim account can be closed.
-    let amount = ctx.accounts.rent_claim.amount;
-    if amount == 0 {
-        return Ok(());
-    }
+    let rent_claim = &mut ctx.accounts.rent_claim;
 
-    // Check if rent fund has enough balance to repay the debt and remain rent-exempt.
+    // Check if rent fund has enough balance to repay any non-zero debt and remain rent-exempt.
     let max_repay = ctx
         .accounts
         .rent_fund
         .lamports()
         .saturating_sub(anchor_rent.minimum_balance(0));
-    if max_repay < amount {
-        return err!(SvmError::InsufficientRentFundBalance);
+    let repay_amount = rent_claim.amount.min(max_repay);
+    if repay_amount == 0 {
+        // Deposit instruction closes rent_claim account with zero debt, so return early if cannot repay any part of it.
+        return Ok(());
     }
 
     let cpi_accounts = system_program::Transfer {
@@ -57,9 +49,21 @@ pub fn repay_rent_fund_debt(ctx: Context<RepayRentFundDebt>) -> Result<()> {
     let rent_fund_seeds: &[&[&[u8]]] = &[&[b"rent_fund", &[ctx.bumps.rent_fund]]];
     let cpi_context =
         CpiContext::new_with_signer(ctx.accounts.system_program.to_account_info(), cpi_accounts, rent_fund_seeds);
-    system_program::transfer(cpi_context, amount)?;
+    system_program::transfer(cpi_context, repay_amount)?;
 
-    emit_cpi!(RepaidRentFundDebt { user: ctx.accounts.recipient.key(), amount });
+    // Update the remaining debt, safe to subtract repay_amount as it is guaranteed to be <= rent_claim.amount.
+    rent_claim.amount -= repay_amount;
+
+    emit_cpi!(RepaidRentFundDebt {
+        user: ctx.accounts.recipient.key(),
+        amount: repay_amount,
+        remaining_user_claim: rent_claim.amount,
+    });
+
+    // Close the claim account if the debt is fully repaid.
+    if rent_claim.amount == 0 {
+        rent_claim.close(ctx.accounts.recipient.to_account_info())?;
+    }
 
     Ok(())
 }

test/svm/SponsoredCctpSrc.Deposit.ts

@@ -800,8 +800,8 @@ describe("sponsored_cctp_src_periphery.deposit", () => {
       messageSentEventData,
     ]);
 
-    let rentClaimAccount = await program.account.rentClaim.fetch(rentClaim);
-    assert.isTrue(rentClaimAccount.amount.eq(new BN(0)), "No debt should be accrued when rent_fund had funding");
+    let rentClaimAccount = await program.account.rentClaim.fetchNullable(rentClaim);
+    assert.isNull(rentClaimAccount, "No debt should be accrued and account closed when rent_fund had funding");
 
     // Withdraw all rent_fund balance to test debt accrual.
     let rentFundBalance = await connection.getBalance(rentFund);
@@ -849,4 +849,108 @@ describe("sponsored_cctp_src_periphery.deposit", () => {
     );
     assert.isNull(await program.account.rentClaim.fetchNullable(rentClaim), "Rent claim account should be closed");
   });
+
+  it("Accrue and partially repay rent_fund debt", async () => {
+    // Withdraw all rent_fund balance to test debt accrual.
+    let rentFundBalance = await connection.getBalance(rentFund);
+    await program.methods
+      .withdrawRentFund({ amount: new BN(rentFundBalance.toString()) })
+      .accounts({
+        recipient: owner,
+        programData,
+      })
+      .rpc();
+
+    [rentClaim] = PublicKey.findProgramAddressSync(
+      [Buffer.from("rent_claim"), depositor.publicKey.toBuffer()],
+      program.programId
+    );
+    let nonce = crypto.randomBytes(32);
+    const deadline = ethers.BigNumber.from(Math.floor(Date.now() / 1000) + 3600);
+
+    const quoteData: SponsoredCCTPQuote = {
+      sourceDomain,
+      destinationDomain: remoteDomain.toNumber(),
+      mintRecipient: ethers.utils.hexlify(mintRecipient),
+      amount: burnAmount,
+      burnToken: ethers.utils.hexlify(burnToken.toBuffer()),
+      destinationCaller: ethers.utils.hexlify(destinationCaller),
+      maxFee,
+      minFinalityThreshold,
+      nonce: ethers.utils.hexlify(nonce),
+      deadline,
+      maxBpsToSponsor,
+      maxUserSlippageBps,
+      finalRecipient: ethers.utils.hexlify(finalRecipient),
+      finalToken: ethers.utils.hexlify(finalToken),
+      executionMode,
+      actionData,
+    };
+    let { quote, signature } = getEncodedQuoteWithSignature(quoteSigner, quoteData);
+
+    const depositAccounts = {
+      signer: depositor.publicKey,
+      payer: depositor.publicKey,
+      state,
+      rentFund,
+      usedNonce: getUsedNonce(nonce),
+      rentClaim,
+      depositorTokenAccount,
+      burnToken,
+      denylistAccount,
+      tokenMessengerMinterSenderAuthority,
+      messageTransmitter,
+      tokenMessenger,
+      remoteTokenMessenger,
+      tokenMinter,
+      localToken,
+      cctpEventAuthority,
+      tokenProgram,
+      messageSentEventData: messageSentEventData.publicKey,
+      program: program.programId,
+    };
+
+    let depositIx = await program.methods.depositForBurn({ quote, signature }).accounts(depositAccounts).instruction();
+    await sendTransactionWithExistingLookupTable(connection, [depositIx], lookupTableAccount, depositor, [
+      messageSentEventData,
+    ]);
+
+    let rentClaimAccount = await program.account.rentClaim.fetch(rentClaim);
+    const usedNonceBalance = await connection.getBalance(depositAccounts.usedNonce);
+    const messageSentEventDataBalance = await connection.getBalance(depositAccounts.messageSentEventData);
+    rentFundBalance = await connection.getBalance(rentFund);
+    const fullClaimAmount = new BN(usedNonceBalance + messageSentEventDataBalance + rentFundBalance);
+    assert.isTrue(
+      rentClaimAccount.amount.eq(fullClaimAmount),
+      "Rent claim should have accrued debt for account creation"
+    );
+
+    // Without funding rent claim account should keep the debt.
+    await program.methods
+      .repayRentFundDebt()
+      .accounts({ recipient: depositor.publicKey, program: program.programId })
+      .rpc();
+    rentClaimAccount = await program.account.rentClaim.fetch(rentClaim);
+    assert.isTrue(rentClaimAccount.amount.eq(fullClaimAmount), "Rent claim should not been repaid");
+
+    // Test partial repayment of 1 lamport (rent_fund should already hold its minimum rent-free balance)
+    const partialRepayment = 1;
+    await requestAndConfirmAirdrop(connection, rentFund, partialRepayment);
+    const userBalanceBefore = await connection.getBalance(depositor.publicKey);
+    await program.methods
+      .repayRentFundDebt()
+      .accounts({ recipient: depositor.publicKey, program: program.programId })
+      .rpc();
+    const userBalanceAfter = await connection.getBalance(depositor.publicKey);
+    assert.strictEqual(
+      userBalanceAfter - userBalanceBefore,
+      partialRepayment,
+      "User should have been refunded only part of the claim"
+    );
+    rentClaimAccount = await program.account.rentClaim.fetch(rentClaim);
+    assert.isTrue(
+      rentClaimAccount.amount.eq(fullClaimAmount.sub(new BN(partialRepayment))),
+      "Rent claim should have been partially repaid"
+    );
+  });
 });