odra-modules 2.7.1

Collection of reusable Odra modules.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

#[cfg(test)]
mod allowance_tests {
    use core::ops::Add;

    use odra::casper_types::U256;
    use odra::host::{Deployer, HostRef, NoArgs};
    use odra::prelude::*;

    use crate::cep18::cep18_client_contract::Cep18ClientContract;
    use crate::cep18::errors::Error::InsufficientAllowance;
    use crate::cep18_token::tests::{
        invert_address, setup, ALLOWANCE_AMOUNT_1, ALLOWANCE_AMOUNT_2, TRANSFER_AMOUNT_1
    };
    use crate::cep18_token::utils::Cep18ExampleHostRef;

    fn test_approve_for(
        cep18_token: &mut Cep18ExampleHostRef,
        sender: Address,
        owner: Address,
        spender: Address
    ) {
        let amount = TRANSFER_AMOUNT_1.into();

        // initial allowance is zero
        assert_eq!(cep18_token.allowance(&owner, &spender), 0.into());

        // when the owner approves the spender to spend tokens on their behalf
        cep18_token.env().set_caller(sender);
        cep18_token.approve(&spender, &amount);

        // then the allowance is set
        assert_eq!(cep18_token.allowance(&owner, &spender), amount);

        // when new allowance is set
        cep18_token.approve(&spender, &(amount.add(U256::one())));

        // then the allowance is updated
        assert_eq!(
            cep18_token.allowance(&owner, &spender),
            amount.add(U256::one())
        );

        // swapping address types
        let inverted_owner = invert_address(owner);
        let inverted_spender = invert_address(spender);
        assert_eq!(
            cep18_token.allowance(&inverted_owner, &inverted_spender),
            U256::zero()
        );
    }

    #[test]
    fn should_approve_funds() {
        // given a token
        let mut cep18_token = setup();
        let owner = cep18_token.env().get_account(0);
        let alice = cep18_token.env().get_account(1);
        let token_address = cep18_token.address();
        let client_contract = Cep18ClientContract::deploy(cep18_token.env(), NoArgs);
        let another_client_contract = Cep18ClientContract::deploy(cep18_token.env(), NoArgs);

        let client_contract_address = client_contract.address();
        let another_client_contract_address = another_client_contract.address();

        // account to account
        test_approve_for(&mut cep18_token, owner, owner, alice);

        // account to contract
        cep18_token.approve(&client_contract_address, &ALLOWANCE_AMOUNT_1.into());
        assert_eq!(
            cep18_token.allowance(&owner, &client_contract_address),
            ALLOWANCE_AMOUNT_1.into()
        );

        client_contract.transfer_from_as_stored_contract(
            token_address,
            owner,
            client_contract_address,
            ALLOWANCE_AMOUNT_1.into()
        );
        assert_eq!(
            cep18_token.balance_of(&client_contract_address),
            ALLOWANCE_AMOUNT_1.into()
        );

        // contract to contract
        client_contract.approve_as_stored_contract(
            token_address,
            another_client_contract_address,
            ALLOWANCE_AMOUNT_1.into()
        );
        assert_eq!(
            cep18_token.allowance(&client_contract_address, &another_client_contract_address),
            ALLOWANCE_AMOUNT_1.into()
        );

        another_client_contract.transfer_from_as_stored_contract(
            token_address,
            client_contract_address,
            another_client_contract_address,
            ALLOWANCE_AMOUNT_1.into()
        );
        assert_eq!(
            cep18_token.balance_of(&another_client_contract_address),
            ALLOWANCE_AMOUNT_1.into()
        );
    }

    #[test]
    fn should_not_transfer_from_without_enough_allowance() {
        // given a token
        let mut cep18_token = setup();
        let owner = cep18_token.env().get_account(0);
        let alice = cep18_token.env().get_account(1);

        // when the owner approves the spender to spend tokens on their behalf
        cep18_token.approve(&alice, &ALLOWANCE_AMOUNT_1.into());

        // then the allowance is set
        assert_eq!(
            cep18_token.allowance(&owner, &alice),
            ALLOWANCE_AMOUNT_1.into()
        );

        // and transferring more is not possible
        cep18_token.env().set_caller(alice);
        let result =
            cep18_token.try_transfer_from(&owner, &alice, &U256::from(ALLOWANCE_AMOUNT_1 + 1));
        assert_eq!(result.err().unwrap(), InsufficientAllowance.into());

        // but transferring less is possible
        cep18_token.transfer_from(&owner, &alice, &U256::from(ALLOWANCE_AMOUNT_1));
    }

    #[test]
    fn test_decrease_allowance() {
        // given a token
        let mut cep18_token = setup();
        let owner = cep18_token.env().get_account(0);
        let alice = cep18_token.env().get_account(1);

        // when the owner approves the spender to spend tokens on their behalf
        cep18_token.approve(&alice, &ALLOWANCE_AMOUNT_1.into());

        // then the allowance is set
        assert_eq!(
            cep18_token.allowance(&owner, &alice),
            ALLOWANCE_AMOUNT_1.into()
        );

        // when the owner decreases the allowance
        cep18_token.decrease_allowance(&alice, &ALLOWANCE_AMOUNT_2.into());

        // then the allowance is decreased
        assert_eq!(
            cep18_token.allowance(&owner, &alice),
            (ALLOWANCE_AMOUNT_1 - ALLOWANCE_AMOUNT_2).into()
        );

        // when the allowance is increased
        cep18_token.increase_allowance(&alice, &ALLOWANCE_AMOUNT_1.into());

        // then the allowance is increased
        assert_eq!(
            cep18_token.allowance(&owner, &alice),
            ((ALLOWANCE_AMOUNT_1 * 2) - ALLOWANCE_AMOUNT_2).into()
        );
    }
}