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

use crate::{
    CreateRedeemer, MutTokenPair, ReadonlyTokenPair, RedeemTokens, RedeemTokensFromMintProxy,
};
use anchor_lang::prelude::*;
use anchor_spl::token;
use vipers::validate::Validate;
use vipers::{assert_ata, assert_keys_eq, assert_owner};

impl<'info> Validate<'info> for CreateRedeemer<'info> {
    fn validate(&self) -> ProgramResult {
        self.tokens.validate()?;

        assert_ata!(
            self.tokens.redemption_vault,
            self.redeemer,
            self.tokens.redemption_mint
        );

        Ok(())
    }
}

impl<'info> Validate<'info> for RedeemTokens<'info> {
    fn validate(&self) -> ProgramResult {
        self.tokens.validate()?;
        self.tokens.validate_token_accounts(&self.redeemer)?;

        assert_keys_eq!(
            self.iou_source.mint,
            self.redeemer.iou_mint,
            "iou_source.mint"
        );

        require!(self.source_authority.is_signer, Unauthorized);
        assert_keys_eq!(
            self.source_authority,
            self.redemption_destination.owner,
            "redemption_destination.owner"
        );

        Ok(())
    }
}

impl<'info> Validate<'info> for RedeemTokensFromMintProxy<'info> {
    fn validate(&self) -> ProgramResult {
        self.redeem_ctx.validate()?;

        assert_keys_eq!(
            self.minter_info.minter,
            self.redeem_ctx.redeemer,
            "minter_info.minter"
        );
        assert_keys_eq!(
            self.mint_proxy_state.token_mint,
            self.redeem_ctx.redeemer.redemption_mint,
            "redemption_mint"
        );

        assert_keys_eq!(self.mint_proxy_program, mint_proxy::ID);
        assert_keys_eq!(
            self.proxy_mint_authority,
            self.mint_proxy_state.proxy_mint_authority,
            "proxy_mint_authority"
        );

        assert_owner!(self.mint_proxy_state, mint_proxy::ID);

        Ok(())
    }
}

impl<'info> Validate<'info> for ReadonlyTokenPair<'info> {
    fn validate(&self) -> ProgramResult {
        require!(
            self.iou_mint.decimals == self.redemption_mint.decimals,
            DecimalsMismatch
        );
        assert_keys_eq!(self.redemption_vault.mint, self.redemption_mint);

        assert_owner!(self.iou_mint, token::ID);
        assert_owner!(self.redemption_mint, token::ID);
        assert_owner!(self.redemption_vault, token::ID);

        Ok(())
    }
}

impl<'info> Validate<'info> for MutTokenPair<'info> {
    fn validate(&self) -> ProgramResult {
        assert_keys_eq!(self.redemption_vault.mint, self.redemption_mint);

        assert_owner!(self.iou_mint, token::ID);
        assert_owner!(self.redemption_mint, token::ID);
        assert_owner!(self.redemption_vault, token::ID);

        Ok(())
    }
}