light-compressed-pda 0.3.1

Generalized PDA compression on Solana
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use crate::{
    errors::CompressedPdaError,
    sdk::accounts::{InvokeAccounts, SignerAccounts},
    InstructionDataInvoke,
};
use aligned_sized::*;
use anchor_lang::{
    prelude::*,
    solana_program::{account_info::AccountInfo, pubkey::Pubkey},
    Bumps,
};

#[account]
#[aligned_sized(anchor)]
pub struct CompressedSolPda {}

#[constant]
pub const COMPRESSED_SOL_PDA_SEED: &[u8] = b"compressed_sol_pda";

pub fn compression_lamports<
    'a,
    'b,
    'c: 'info,
    'info,
    A: InvokeAccounts<'info> + SignerAccounts<'info> + Bumps,
>(
    inputs: &'a InstructionDataInvoke,
    ctx: &'a Context<'a, 'b, 'c, 'info, A>,
) -> Result<()> {
    if inputs.is_compress {
        compress_lamports(inputs, ctx)
    } else if inputs.compression_lamports.is_some() {
        decompress_lamports(inputs, ctx)
    } else {
        Ok(())
    }
}

pub fn decompress_lamports<
    'a,
    'b,
    'c: 'info,
    'info,
    A: InvokeAccounts<'info> + SignerAccounts<'info> + Bumps,
>(
    inputs: &'a InstructionDataInvoke,
    ctx: &'a Context<'a, 'b, 'c, 'info, A>,
) -> Result<()> {
    let recipient = match ctx.accounts.get_compression_recipient().as_ref() {
        Some(compression_recipient) => compression_recipient.to_account_info(),
        None => return err!(CompressedPdaError::DecompressRecipientUndefinedForDecompressSol),
    };
    let compressed_sol_pda = match ctx.accounts.get_compressed_sol_pda().as_ref() {
        Some(compressed_sol_pda) => compressed_sol_pda.to_account_info(),
        None => return err!(CompressedPdaError::CompressedSolPdaUndefinedForDecompressSol),
    };
    let lamports = match inputs.compression_lamports {
        Some(lamports) => lamports,
        None => return err!(CompressedPdaError::DeCompressLamportsUndefinedForDecompressSol),
    };

    transfer_lamports(&compressed_sol_pda, &recipient, lamports)?;

    Ok(())
}

pub fn compress_lamports<
    'a,
    'b,
    'c: 'info,
    'info,
    A: InvokeAccounts<'info> + SignerAccounts<'info> + Bumps,
>(
    inputs: &'a InstructionDataInvoke,
    ctx: &'a Context<'a, 'b, 'c, 'info, A>,
) -> Result<()> {
    let recipient = match ctx.accounts.get_compressed_sol_pda().as_ref() {
        Some(compressed_sol_pda) => compressed_sol_pda.to_account_info(),
        None => return err!(CompressedPdaError::CompressedSolPdaUndefinedForCompressSol),
    };
    let lamports = match inputs.compression_lamports {
        Some(lamports) => lamports,
        None => return err!(CompressedPdaError::DeCompressLamportsUndefinedForCompressSol),
    };

    transfer_lamports_compress(
        &ctx.accounts.get_authority().to_account_info(),
        &recipient,
        lamports,
    )
}

pub fn transfer_lamports_compress<'info>(
    from: &AccountInfo<'info>,
    to: &AccountInfo<'info>,
    lamports: u64,
) -> Result<()> {
    let instruction =
        anchor_lang::solana_program::system_instruction::transfer(from.key, to.key, lamports);
    anchor_lang::solana_program::program::invoke(&instruction, &[from.clone(), to.clone()])?;
    Ok(())
}

pub fn transfer_lamports<'info>(
    from: &AccountInfo<'info>,
    to: &AccountInfo<'info>,
    lamports: u64,
) -> Result<()> {
    let instruction =
        anchor_lang::solana_program::system_instruction::transfer(from.key, to.key, lamports);
    let (_, bump) =
        anchor_lang::prelude::Pubkey::find_program_address(&[COMPRESSED_SOL_PDA_SEED], &crate::ID);
    let bump = &[bump];
    let seeds = &[&[COMPRESSED_SOL_PDA_SEED, bump][..]];
    anchor_lang::solana_program::program::invoke_signed(
        &instruction,
        &[from.clone(), to.clone()],
        seeds,
    )?;
    Ok(())
}