update poseidon_rent_payer_code

Author: adpthegreat

basics/pda-rent-payer/poseidon/pda_rent_payer/programs/pda_rent_payer/src/lib.rs

@@ -1,40 +1,52 @@
 use anchor_lang::prelude::*;
-use anchor_lang::system_program::{transfer, Transfer};
+use anchor_lang::system_program::{Transfer, transfer};
 declare_id!("BYj8GpV9hpv9PAVdwoWFCTMkysJkk5jstYjuCrw4pxem");
 #[program]
 pub mod pda_rent_payer {
     use super::*;
-    pub fn init_rent_vault(
-        ctx: Context<InitRentVaultContext>,
-        fund_lamports: u64,
+    pub fn init_rent_vault(ctx: Context<InitRentVaultContext>) -> Result<()> {
+        ctx.accounts.state.owner = ctx.accounts.owner.key();
+        ctx.accounts.state.state_bump = ctx.bumps.state;
+        ctx.accounts.state.auth_bump = ctx.bumps.auth;
+        ctx.accounts.state.vault_bump = ctx.bumps.vault;
+        Ok(())
+    }
+    pub fn deposit_to_rent_vault(
+        ctx: Context<DepositToRentVaultContext>,
+        amount: u64,
     ) -> Result<()> {
-        ctx.accounts.rent_vault.rent_vault_bump = ctx.bumps.rent_vault;
         let transfer_accounts = Transfer {
             from: ctx.accounts.owner.to_account_info(),
-            to: ctx.accounts.rent_vault.to_account_info(),
+            to: ctx.accounts.vault.to_account_info(),
         };
         let cpi_ctx = CpiContext::new(
             ctx.accounts.system_program.to_account_info(),
             transfer_accounts,
         );
-        transfer(cpi_ctx, fund_lamports)?;
+        transfer(cpi_ctx, amount)?;
         Ok(())
     }
     pub fn create_new_account(
         ctx: Context<CreateNewAccountContext>,
-        transfer_amount: u64,
+        amount: u64,
     ) -> Result<()> {
-        ctx.accounts.new_account.owner = ctx.accounts.owner.key();
-        ctx.accounts.new_account.account_bump = ctx.bumps.new_account;
+        ctx.accounts.new_account_state.owner = ctx.accounts.owner.key();
         let transfer_accounts = Transfer {
-            from: ctx.accounts.rent_vault.to_account_info(),
-            to: ctx.accounts.new_account.to_account_info(),
+            from: ctx.accounts.vault.to_account_info(),
+            to: ctx.accounts.new_account_state.to_account_info(),
         };
-        let cpi_ctx = CpiContext::new(
+        let seeds = &[
+            b"vault",
+            ctx.accounts.auth.to_account_info().key.as_ref(),
+            &[ctx.accounts.state.vault_bump],
+        ];
+        let pda_signer = &[&seeds[..]];
+        let cpi_ctx = CpiContext::new_with_signer(
             ctx.accounts.system_program.to_account_info(),
             transfer_accounts,
+            pda_signer,
         );
-        transfer(cpi_ctx, transfer_amount)?;
+        transfer(cpi_ctx, amount)?;
         Ok(())
     }
 }
@@ -43,39 +55,74 @@ pub struct InitRentVaultContext<'info> {
     #[account(
         init,
         payer = owner,
-        space = 9,
-        seeds = [b"rent_vault",
+        space = 8,
+        seeds = [b"vault",
+        auth.key().as_ref()],
+        bump,
+    )]
+    pub vault: Account<'info, RentVault>,
+    #[account(mut)]
+    pub owner: Signer<'info>,
+    #[account(
+        init,
+        payer = owner,
+        space = 43,
+        seeds = [b"state",
         owner.key().as_ref()],
         bump,
     )]
-    pub rent_vault: Account<'info, RentState>,
+    pub state: Account<'info, RentAccountState>,
+    #[account(seeds = [b"auth", state.key().as_ref()], bump)]
+    /// CHECK: This acc is safe
+    pub auth: UncheckedAccount<'info>,
+    pub system_program: Program<'info, System>,
+}
+#[derive(Accounts)]
+pub struct DepositToRentVaultContext<'info> {
     #[account(mut)]
     pub owner: Signer<'info>,
+    #[account(seeds = [b"auth", state.key().as_ref()], bump = state.auth_bump)]
+    /// CHECK: This acc is safe
+    pub auth: UncheckedAccount<'info>,
+    #[account(seeds = [b"vault", auth.key().as_ref()], bump = state.vault_bump)]
+    pub vault: Account<'info, RentVault>,
+    #[account(seeds = [b"state", owner.key().as_ref()], bump = state.state_bump)]
+    pub state: Account<'info, RentAccountState>,
     pub system_program: Program<'info, System>,
 }
 #[derive(Accounts)]
 pub struct CreateNewAccountContext<'info> {
-    #[account()]
-    pub rent_vault: Account<'info, RentState>,
     #[account(
         init,
         payer = owner,
         space = 41,
-        seeds = [b"account",
+        seeds = [b"new_account",
         owner.key().as_ref()],
         bump,
     )]
-    pub new_account: Account<'info, AccountState>,
+    pub new_account_state: Account<'info, NewAccountState>,
     #[account(mut)]
     pub owner: Signer<'info>,
+    #[account(seeds = [b"auth", state.key().as_ref()], bump = state.auth_bump)]
+    /// CHECK: This acc is safe
+    pub auth: UncheckedAccount<'info>,
+    #[account(mut, seeds = [b"vault", auth.key().as_ref()], bump = state.vault_bump)]
+    pub vault: SystemAccount<'info>,
+    #[account(seeds = [b"state", owner.key().as_ref()], bump = state.state_bump)]
+    pub state: Account<'info, RentAccountState>,
     pub system_program: Program<'info, System>,
 }
 #[account]
-pub struct AccountState {
+pub struct RentAccountState {
     pub owner: Pubkey,
-    pub account_bump: u8,
+    pub state_bump: u8,
+    pub auth_bump: u8,
+    pub vault_bump: u8,
 }
 #[account]
-pub struct RentState {
-    pub rent_vault_bump: u8,
+pub struct NewAccountState {
+    pub owner: Pubkey,
+    pub new_account_bump: u8,
 }
+#[account]
+pub struct RentVault {}

basics/pda-rent-payer/poseidon/pda_rent_payer/tests/bankrun.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test';
 import * as anchor from '@coral-xyz/anchor';
-import { Keypair, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
+import { clusterApiUrl, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
 import { BankrunProvider } from 'anchor-bankrun';
 import { assert } from 'chai';
 import { startAnchor } from 'solana-bankrun';
@@ -18,13 +18,60 @@ describe('PDA Rent-Payer', async () => {
   const connection = provider.connection;
 
   // PDA for the Rent Vault
-  const [rentVaultPDA, _] = PublicKey.findProgramAddressSync([Buffer.from('rent_vault'), wallet.publicKey.toBuffer()], program.programId);
+  const auth = new Keypair()
+
+  const [authPDA, authBump] = PublicKey.findProgramAddressSync(
+      [Buffer.from("auth")],
+      PROGRAM_ID
+    );
+
+const [rentVaultPDA, vaultBump] = PublicKey.findProgramAddressSync(
+      [Buffer.from("vault"),auth.publicKey.toBuffer()],
+      PROGRAM_ID
+);
+
+ const [newAccountPDA, newAccountBump] = PublicKey.findProgramAddressSync(
+   [Buffer.from("new_account"),],
+   PROGRAM_ID
+ );
+//   const [statePDA, stateBump] = PublicKey.findProgramAddressSync(
+//     [Buffer.from("state"), wallet.publicKey.toBuffer()],
+//     PROGRAM_ID
+//   );
+
+
   console.log(rentVaultPDA, 'this is the rent vault pda');
+  console.log(authPDA, 'this is the auth pda')
+ console.log(newAccountPDA, 'this is the new account pda')
+
   it('Initialize the Rent Vault', async () => {
+
+   const tx = await program.methods
+      .initRentVault()
+      .accounts({
+        owner: wallet.publicKey,
+      })
+      .rpc();
+
+    // Check rent vault balance
+
+    const accountInfo = await program.provider.connection.getAccountInfo(rentVaultPDA);
+
+    console.log(accountInfo, "this is the account info")
+
+    const lamports = await connection.getMinimumBalanceForRentExemption(8);
+
+    assert(accountInfo !== null, 'Rent vault account does not exist');
+
+    assert(accountInfo.lamports === lamports, 'Incorrect rent vault balance');
+
+  });
+
+  it('Deposit to the Rent Vault', async () => {
     // 1 SOL
     const fundAmount = new anchor.BN(LAMPORTS_PER_SOL);
     await program.methods
-      .initRentVault(fundAmount)
+      .depositToRentVault(fundAmount)
       .accounts({
         owner: wallet.publicKey,
       })
@@ -33,40 +80,46 @@ describe('PDA Rent-Payer', async () => {
     // Check rent vault balance
     const accountInfo = await program.provider.connection.getAccountInfo(rentVaultPDA);
 
-    // 9 is the space the rentVault occupies, poseidon automatically generates space for you when you initialize a pda
-    const lamports = await connection.getMinimumBalanceForRentExemption(9);
+    // 9 is the space the rentVault account occupies, poseidon automatically generates space for you when you initialize a pda
+    const lamports = await connection.getMinimumBalanceForRentExemption(43);
 
     assert(accountInfo !== null, 'Rent vault account does not exist');
 
     assert(accountInfo.lamports === fundAmount.toNumber() + lamports, 'Incorrect rent vault balance');
   });
 
   it('Create a new account using the Rent Vault', async () => {
-    // Generate a new keypair for the new account
     const newAccount = new Keypair();
 
-    const amount = new anchor.BN(LAMPORTS_PER_SOL);
+    const fundAmount = new anchor.BN(LAMPORTS_PER_SOL);
 
     await program.methods
-      .createNewAccount(amount)
+      .createNewAccount(fundAmount)
       .accounts({
         owner: newAccount.publicKey,
-        rentVault: rentVaultPDA,
       })
       .signers([newAccount])
       .rpc();
 
-    // Minimum balance for rent exemption for new account
-    const lamports = await connection.getMinimumBalanceForRentExemption(41);
-
     // Check that the account was created
-    const accountInfo = await connection.getAccountInfo(newAccount.publicKey);
-
+    const accountInfo = await connection.getAccountInfo(newAccountPDA);
+    
+    // 9 is the space the newAccount occupies, poseidon automatically generates space for you when you initialize a pda
+    const lamports = await connection.getMinimumBalanceForRentExemption(41);
+    
     console.log(lamports);
     console.log(accountInfo.lamports);
 
-    assert(accountInfo !== null, 'new account does not exist');
+    assert(accountInfo !== null, "Rent vault account does not exist");
 
-    assert(accountInfo.lamports === amount.toNumber() + lamports, 'Incorrect account balance');
+    assert(
+      accountInfo.lamports === fundAmount.toNumber() + lamports,
+      "Incorrect rent vault balance"
+    );
   });
 });
+
+//
+//owner == payer, use payer 
+
+//payer --> rentvault --> newAccount