Burn functionality

execution_engine/src/core/runtime/mint_internal.rs

@@ -10,7 +10,7 @@ use crate::{
     core::{engine_state::SystemContractRegistry, execution},
     storage::global_state::StateReader,
     system::mint::{
-        runtime_provider::RuntimeProvider, storage_provider::StorageProvider,
+        detail, runtime_provider::RuntimeProvider, storage_provider::StorageProvider,
         system_provider::SystemProvider, Mint,
     },
 };
@@ -189,4 +189,31 @@ where
     R: StateReader<Key, StoredValue>,
     R::Error: Into<execution::Error>,
 {
+    /// Burns native tokens.
+    fn burn(&mut self, purse: URef, amount: U512) -> Result<(), Error> {
+        let purse_key = Key::URef(purse);
+        self.context
+            .validate_writeable(&purse_key)
+            .map_err(|_| Error::InvalidAccessRights)?;
+        self.context
+            .validate_key(&purse_key)
+            .map_err(|_| Error::InvalidURef)?;
+
+        let source_balance: U512 = match self.read_balance(purse)? {
+            Some(source_balance) => source_balance,
+            None => return Err(Error::PurseNotFound),
+        };
+
+        let new_balance = match source_balance.checked_sub(amount) {
+            Some(value) => value,
+            None => U512::zero(),
+        };
+
+        // source_balance is >= than new_balance
+        // this should block user from reducing totaly supply beyond what they own
+        let burned_amount = source_balance - new_balance;
+
+        self.write_balance(purse, new_balance)?;
+        detail::reduce_total_supply_unchecked(self, burned_amount)
+    }
 }

execution_engine/src/core/runtime/mod.rs

@@ -650,6 +650,15 @@ where
                 let result: Result<(), mint::Error> = mint_runtime.reduce_total_supply(amount);
                 CLValue::from_t(result).map_err(Self::reverter)
             })(),
+            // Type: `fn burn(purse: URef, amount: U512)`
+            mint::METHOD_BURN => (|| {
+                mint_runtime.charge_system_contract_call(mint_costs.burn)?;
+
+                let purse: URef = Self::get_named_argument(runtime_args, mint::ARG_PURSE)?;
+                let amount: U512 = Self::get_named_argument(runtime_args, mint::ARG_AMOUNT)?;
+                let result = mint_runtime.burn(purse, amount).map_err(Self::reverter)?;
+                CLValue::from_t(result).map_err(Self::reverter)
+            })(),
             // Type: `fn create() -> URef`
             mint::METHOD_CREATE => (|| {
                 mint_runtime.charge_system_contract_call(mint_costs.create)?;

execution_engine/src/core/runtime_context/mod.rs

@@ -694,7 +694,7 @@ where
     }
 
     /// Validates whether keys used in the `value` are not forged.
-    fn validate_value(&self, value: &StoredValue) -> Result<(), Error> {
+    pub fn validate_value(&self, value: &StoredValue) -> Result<(), Error> {
         match value {
             StoredValue::CLValue(cl_value) => self.validate_cl_value(cl_value),
             StoredValue::Account(account) => {
@@ -768,7 +768,7 @@ where
     }
 
     /// Validates if a [`Key`] refers to a [`URef`] and has a write bit set.
-    fn validate_writeable(&self, key: &Key) -> Result<(), Error> {
+    pub fn validate_writeable(&self, key: &Key) -> Result<(), Error> {
         if self.is_writeable(key) {
             Ok(())
         } else {

execution_engine/src/shared/system_config/mint_costs.rs

@@ -8,6 +8,8 @@ use serde::{Deserialize, Serialize};
 pub const DEFAULT_MINT_COST: u32 = 2_500_000_000;
 /// Default cost of the `reduce_total_supply` mint entry point.
 pub const DEFAULT_REDUCE_TOTAL_SUPPLY_COST: u32 = 10_000;
+/// Default cost of the `burn` mint entry point.
+pub const DEFAULT_BURN_COST: u32 = 10_000;
 /// Default cost of the `create` mint entry point.
 pub const DEFAULT_CREATE_COST: u32 = 2_500_000_000;
 /// Default cost of the `balance` mint entry point.
@@ -27,6 +29,8 @@ pub struct MintCosts {
     pub mint: u32,
     /// Cost of calling the `reduce_total_supply` entry point.
     pub reduce_total_supply: u32,
+    /// Cost of calling the `burn` entry point.
+    pub burn: u32,
     /// Cost of calling the `create` entry point.
     pub create: u32,
     /// Cost of calling the `balance` entry point.
@@ -44,6 +48,7 @@ impl Default for MintCosts {
         Self {
             mint: DEFAULT_MINT_COST,
             reduce_total_supply: DEFAULT_REDUCE_TOTAL_SUPPLY_COST,
+            burn: DEFAULT_BURN_COST,
             create: DEFAULT_CREATE_COST,
             balance: DEFAULT_BALANCE_COST,
             transfer: DEFAULT_TRANSFER_COST,
@@ -60,6 +65,7 @@ impl ToBytes for MintCosts {
         let Self {
             mint,
             reduce_total_supply,
+            burn,
             create,
             balance,
             transfer,
@@ -69,6 +75,7 @@ impl ToBytes for MintCosts {
 
         ret.append(&mut mint.to_bytes()?);
         ret.append(&mut reduce_total_supply.to_bytes()?);
+        ret.append(&mut burn.to_bytes()?);
         ret.append(&mut create.to_bytes()?);
         ret.append(&mut balance.to_bytes()?);
         ret.append(&mut transfer.to_bytes()?);
@@ -82,6 +89,7 @@ impl ToBytes for MintCosts {
         let Self {
             mint,
             reduce_total_supply,
+            burn,
             create,
             balance,
             transfer,
@@ -91,6 +99,7 @@ impl ToBytes for MintCosts {
 
         mint.serialized_length()
             + reduce_total_supply.serialized_length()
+            + burn.serialized_length()
             + create.serialized_length()
             + balance.serialized_length()
             + transfer.serialized_length()
@@ -102,7 +111,8 @@ impl ToBytes for MintCosts {
 impl FromBytes for MintCosts {
     fn from_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), casper_types::bytesrepr::Error> {
         let (mint, rem) = FromBytes::from_bytes(bytes)?;
-        let (reduce_total_supply, rem) = FromBytes::from_bytes(rem)?;
+        let (reduce_total_supply, _) = FromBytes::from_bytes(rem)?;
+        let (burn, rem) = FromBytes::from_bytes(bytes)?;
         let (create, rem) = FromBytes::from_bytes(rem)?;
         let (balance, rem) = FromBytes::from_bytes(rem)?;
         let (transfer, rem) = FromBytes::from_bytes(rem)?;
@@ -113,6 +123,7 @@ impl FromBytes for MintCosts {
             Self {
                 mint,
                 reduce_total_supply,
+                burn,
                 create,
                 balance,
                 transfer,
@@ -128,6 +139,7 @@ impl Distribution<MintCosts> for Standard {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> MintCosts {
         MintCosts {
             mint: rng.gen(),
+            burn: rng.gen(),
             reduce_total_supply: rng.gen(),
             create: rng.gen(),
             balance: rng.gen(),
@@ -149,6 +161,7 @@ pub mod gens {
         pub fn mint_costs_arb()(
             mint in num::u32::ANY,
             reduce_total_supply in num::u32::ANY,
+            burn in num::u32::ANY,
             create in num::u32::ANY,
             balance in num::u32::ANY,
             transfer in num::u32::ANY,
@@ -158,6 +171,7 @@ pub mod gens {
             MintCosts {
                 mint,
                 reduce_total_supply,
+                burn,
                 create,
                 balance,
                 transfer,

execution_engine/src/system/mint.rs

@@ -1,3 +1,4 @@
+pub(crate) mod detail;
 pub(crate) mod runtime_provider;
 pub(crate) mod storage_provider;
 pub(crate) mod system_provider;
@@ -15,6 +16,8 @@ use casper_types::{
     Key, Phase, PublicKey, StoredValue, URef, U512,
 };
 
+use detail::reduce_total_supply_unchecked;
+
 use crate::{
     core::engine_state::SystemContractRegistry,
     system::mint::{
@@ -54,6 +57,9 @@ pub trait Mint: RuntimeProvider + StorageProvider + SystemProvider {
         Ok(purse_uref)
     }
 
+    /// Burns native tokens.
+    fn burn(&mut self, purse: URef, amount: U512) -> Result<(), Error>;
+
     /// Reduce total supply by `amount`. Returns unit on success, otherwise
     /// an error.
     fn reduce_total_supply(&mut self, amount: U512) -> Result<(), Error> {
@@ -63,29 +69,7 @@ pub trait Mint: RuntimeProvider + StorageProvider + SystemProvider {
             return Err(Error::InvalidTotalSupplyReductionAttempt);
         }
 
-        if amount.is_zero() {
-            return Ok(()); // no change to supply
-        }
-
-        // get total supply or error
-        let total_supply_uref = match self.get_key(TOTAL_SUPPLY_KEY) {
-            Some(Key::URef(uref)) => uref,
-            Some(_) => return Err(Error::MissingKey), // TODO
-            None => return Err(Error::MissingKey),
-        };
-        let total_supply: U512 = self
-            .read(total_supply_uref)?
-            .ok_or(Error::TotalSupplyNotFound)?;
-
-        // decrease total supply
-        let reduced_total_supply = total_supply
-            .checked_sub(amount)
-            .ok_or(Error::ArithmeticOverflow)?;
-
-        // update total supply
-        self.write(total_supply_uref, reduced_total_supply)?;
-
-        Ok(())
+        reduce_total_supply_unchecked(self, amount)
     }
 
     /// Read balance of given `purse`.

execution_engine/src/system/mint/detail.rs

@@ -0,0 +1,39 @@
+use casper_types::{
+    system::{mint, mint::TOTAL_SUPPLY_KEY},
+    Key, U512,
+};
+
+use crate::system::mint::{runtime_provider::RuntimeProvider, storage_provider::StorageProvider};
+
+// Please do not expose this to the user!
+pub(crate) fn reduce_total_supply_unchecked<P>(
+    auction: &mut P,
+    amount: U512,
+) -> Result<(), mint::Error>
+where
+    P: StorageProvider + RuntimeProvider + ?Sized,
+{
+    if amount.is_zero() {
+        return Ok(()); // no change to supply
+    }
+
+    // get total supply or error
+    let total_supply_uref = match auction.get_key(TOTAL_SUPPLY_KEY) {
+        Some(Key::URef(uref)) => uref,
+        Some(_) => return Err(mint::Error::MissingKey), // TODO
+        None => return Err(mint::Error::MissingKey),
+    };
+    let total_supply: U512 = auction
+        .read(total_supply_uref)?
+        .ok_or(mint::Error::TotalSupplyNotFound)?;
+
+    // decrease total supply
+    let reduced_total_supply = total_supply
+        .checked_sub(amount)
+        .ok_or(mint::Error::ArithmeticOverflow)?;
+
+    // update total supply
+    auction.write(total_supply_uref, reduced_total_supply)?;
+
+    Ok(())
+}