check allowance

azero/contracts/most/lib.rs

@@ -708,7 +708,7 @@ pub mod most {
             amount: u128,
         ) -> Result<(), PSP22Error> {
             let mut psp22: ink::contract_ref!(Burnable) = token.into();
-            psp22.burn(from, amount)
+            psp22.burn_from(from, amount)
         }
     }
 

azero/contracts/psp22-traits/lib.rs

@@ -17,5 +17,8 @@ pub trait Mintable {
 #[ink::trait_definition]
 pub trait Burnable {
     #[ink(message)]
-    fn burn(&mut self, from: AccountId, amount: Balance) -> Result<(), PSP22Error>;
+    fn burn(&mut self, amount: Balance) -> Result<(), PSP22Error>;
+
+    #[ink(message)]
+    fn burn_from(&mut self, from: AccountId, amount: Balance) -> Result<(), PSP22Error>;
 }

azero/contracts/tests/lib.rs

@@ -124,6 +124,17 @@ mod e2e {
         .expect("balance_of should succeed");
 
         let amount_to_send = 1000;
+
+        psp22_approve(
+            &mut client,
+            &alice(),
+            token_address,
+            most_address,
+            amount_to_send,
+        )
+        .await
+        .expect("approval should succeed");
+
         most_send_request(
             &mut client,
             &alice(),
@@ -198,6 +209,16 @@ mod e2e {
             .await
             .expect("should return base fee");
 
+        psp22_approve(
+            &mut client,
+            &alice(),
+            token_address,
+            most_address,
+            amount_to_send,
+        )
+        .await
+        .expect("approval should succeed");
+
         let send_request_res = most_send_request(
             &mut client,
             &alice(),
@@ -952,6 +973,23 @@ mod e2e {
             .return_value())
     }
 
+    async fn psp22_approve(
+        client: &mut E2EClient,
+        caller: &Keypair,
+        token: AccountId,
+        spender: AccountId,
+        amount: u128,
+    ) -> CallResult<(), PSP22Error> {
+        call_message::<TokenRef, _, _, _, _>(
+            client,
+            caller,
+            token,
+            |token| token.approve(spender, amount),
+            None,
+        )
+        .await
+    }
+
     async fn most_committee_rewards(
         client: &mut E2EClient,
         most_address: AccountId,

azero/contracts/token/lib.rs

@@ -232,9 +232,21 @@ pub mod token {
 
     impl Burnable for Token {
         #[ink(message)]
-        fn burn(&mut self, from: AccountId, value: u128) -> Result<(), PSP22Error> {
+        fn burn(&mut self, value: u128) -> Result<(), PSP22Error> {
+            let events = self.data.burn(self.env().caller(), value)?;
+            self.emit_events(events);
+            Ok(())
+        }
+
+        #[ink(message)]
+        fn burn_from(&mut self, from: AccountId, value: u128) -> Result<(), PSP22Error> {
             self.ensure_minter_burner()?;
+            let caller = self.env().caller();
+            if self.data.allowance(from, caller) < value {
+                return Err(PSP22Error::InsufficientAllowance);
+            }
             let events = self.data.burn(from, value)?;
+            self.data.decrease_allowance(from, caller, value)?;
             self.emit_events(events);
             Ok(())
         }
@@ -333,12 +345,14 @@ pub mod token {
         fn minter_burner_can_burn() {
             let mut token = init_contract(INIT_SUPPLY_TEST);
             let alice = default_accounts::<E>().alice;
-            let bob = default_accounts::<E>().bob;
             let charlie = default_accounts::<E>().charlie;
             let alice_balance_before = token.balance_of(alice);
 
+            set_caller::<E>(alice);
+            assert!(token.approve(charlie, 100).is_ok());
+
             set_caller::<E>(charlie);
-            assert!(token.burn(alice, 100).is_ok());
+            assert!(token.burn_from(alice, 100).is_ok());
             assert_eq!(token.balance_of(alice), alice_balance_before - 100);
         }
 
@@ -350,7 +364,7 @@ pub mod token {
 
             set_caller::<E>(bob);
             assert_eq!(
-                token.burn(alice, 100),
+                token.burn_from(alice, 100),
                 Err(PSP22Error::Custom(String::from(
                     "Caller has to be the minter/burner."
                 )))