Cherry pick MIP-124 (#227)

aptos-move/framework/aptos-framework/sources/transaction_fee.move

@@ -1,10 +1,10 @@
 // This module provides an interface to burn or collect and redistribute transaction fees.
 module aptos_framework::transaction_fee {
     use aptos_framework::coin::{Self, AggregatableCoin, BurnCapability, MintCapability};
+    use aptos_framework::aptos_account;
     use aptos_framework::aptos_coin::AptosCoin;
     use aptos_framework::fungible_asset::BurnRef;
     use aptos_framework::system_addresses;
-    use aptos_framework::governed_gas_pool;
     use std::error;
     use std::features;
     use std::option::{Self, Option};
@@ -77,17 +77,31 @@ module aptos_framework::transaction_fee {
     }
 
     /// Burn transaction fees in epilogue.
-    public(friend) fun burn_fee(account: address, fee: u64) {
-        governed_gas_pool::deposit_gas_fee_v2(account, fee)
+    public(friend) fun burn_fee(account: address, fee: u64) acquires AptosFABurnCapabilities, AptosCoinCapabilities {
+        if (exists<AptosFABurnCapabilities>(@aptos_framework)) {
+            let burn_ref = &borrow_global<AptosFABurnCapabilities>(@aptos_framework).burn_ref;
+            aptos_account::burn_from_fungible_store_for_gas(burn_ref, account, fee);
+        } else {
+            let burn_cap = &borrow_global<AptosCoinCapabilities>(@aptos_framework).burn_cap;
+            if (features::operations_default_to_fa_apt_store_enabled()) {
+                let (burn_ref, burn_receipt) = coin::get_paired_burn_ref(burn_cap);
+                aptos_account::burn_from_fungible_store_for_gas(&burn_ref, account, fee);
+                coin::return_paired_burn_ref(burn_ref, burn_receipt);
+            } else {
+                coin::burn_from_for_gas<AptosCoin>(
+                    account,
+                    fee,
+                    burn_cap,
+                );
+            };
+        };
     }
 
     /// Mint refund in epilogue.
-    public(friend) fun mint_and_refund(_account: address, refund: u64) {
-        // refund is 0 when the STORAGE_DELETION_REFUND feature is desactivated.
-        // STORAGE_DELETION_REFUND is not implemented.
-        if (refund > 0) {
-            abort error::not_implemented(ENO_LONGER_SUPPORTED)
-        } 
+    public(friend) fun mint_and_refund(account: address, refund: u64) acquires AptosCoinMintCapability {
+        let mint_cap = &borrow_global<AptosCoinMintCapability>(@aptos_framework).mint_cap;
+        let refund_coin = coin::mint(refund, mint_cap);
+        coin::deposit_for_gas_fee(account, refund_coin);
     }
 
     /// Only called during genesis.
@@ -163,16 +177,16 @@ module aptos_framework::transaction_fee {
     #[deprecated]
     struct CopyCapabilitiesOneShot has key {}
 
-    // Copy Mint and Burn capabilities over to bridge
-    // Can only be called once after which it will assert
+    /// Copy Mint and Burn capabilities over to bridge
+    /// Can only be called once after which it will assert
     #[deprecated]
-    public fun copy_capabilities_for_bridge(_aptos_framework: &signer) : (MintCapability<AptosCoin>, BurnCapability<AptosCoin>){
+    public fun copy_capabilities_for_bridge(aptos_framework: &signer) : (MintCapability<AptosCoin>, BurnCapability<AptosCoin>){
        abort error::not_implemented(ENO_LONGER_SUPPORTED)
     }
 
     /// Copy Mint and Burn capabilities over to bridge
     /// Can only be called once after which it will assert
-    public fun copy_capabilities_for_native_bridge(_aptos_framework: &signer) : (MintCapability<AptosCoin>, BurnCapability<AptosCoin>){
+    public fun copy_capabilities_for_native_bridge(aptos_framework: &signer) : (MintCapability<AptosCoin>, BurnCapability<AptosCoin>){
         abort error::not_implemented(ENO_LONGER_SUPPORTED)
     }
 }

aptos-move/framework/aptos-framework/sources/transaction_fee.spec.move

@@ -114,8 +114,29 @@ spec aptos_framework::transaction_fee {
         ensures coin::supply<AptosCoin> == old(coin::supply<AptosCoin>) - amount;
     }
 
-    spec mint_and_refund(_account: address, refund: u64) {
-        aborts_if (refund != 0);
+    spec mint_and_refund(account: address, refund: u64) {
+        use aptos_std::type_info;
+        use aptos_framework::aptos_coin::AptosCoin;
+        use aptos_framework::coin::{CoinInfo, CoinStore};
+        use aptos_framework::coin;
+        // TODO(fa_migration)
+        pragma verify = false;
+        // pragma opaque;
+
+        let aptos_addr = type_info::type_of<AptosCoin>().account_address;
+
+        aborts_if (refund != 0) && !exists<CoinInfo<AptosCoin>>(aptos_addr);
+        include coin::CoinAddAbortsIf<AptosCoin> { amount: refund };
+
+        aborts_if !exists<CoinStore<AptosCoin>>(account);
+        // modifies global<CoinStore<AptosCoin>>(account);
+
+        aborts_if !exists<AptosCoinMintCapability>(@aptos_framework);
+
+        let supply = coin::supply<AptosCoin>;
+        let post post_supply = coin::supply<AptosCoin>;
+        aborts_if [abstract] supply + refund > MAX_U128;
+        ensures post_supply == supply + refund;
     }
 
     /// Ensure caller is admin.

aptos-move/framework/aptos-framework/sources/transaction_validation.move

@@ -619,20 +619,28 @@ module aptos_framework::transaction_validation {
                 );
             };
 
-            if (transaction_fee_amount > storage_fee_refunded) {
-                let burn_amount = transaction_fee_amount - storage_fee_refunded;
+            if (features::storage_deletion_refund_enabled()){
+                if (transaction_fee_amount > storage_fee_refunded) {
+                    let burn_amount = transaction_fee_amount - storage_fee_refunded;
+                    if (features::governed_gas_pool_enabled()){
+                        governed_gas_pool::deposit_gas_fee_v2(gas_payer, burn_amount);
+                    } else {
+                        transaction_fee::burn_fee(gas_payer, burn_amount);
+                    }
+                } else if (transaction_fee_amount < storage_fee_refunded) {
+                    let mint_amount = storage_fee_refunded - transaction_fee_amount;
+                    // TODO: we cannot mint to do storage refund. We need to have a storage refund pool
+                    if (!features::governed_gas_pool_enabled()){
+                        transaction_fee::mint_and_refund(gas_payer, mint_amount);
+                    }
+                };
+            } else {
                 if (features::governed_gas_pool_enabled()){
-                    governed_gas_pool::deposit_gas_fee_v2(gas_payer, burn_amount);
+                    governed_gas_pool::deposit_gas_fee_v2(gas_payer, transaction_fee_amount);
                 } else {
-                    transaction_fee::burn_fee(gas_payer, burn_amount);
+                    transaction_fee::burn_fee(gas_payer, transaction_fee_amount);
                 }
-            } else if (transaction_fee_amount < storage_fee_refunded) {
-                let mint_amount = storage_fee_refunded - transaction_fee_amount;
-                // TODO: we cannot mint to do storage refund. We need to have a storage refund pool
-                if (!features::governed_gas_pool_enabled()){
-                    transaction_fee::mint_and_refund(gas_payer, mint_amount);
-                }
-            };
+            }
         };
 
         // Increment sequence number

aptos-move/framework/move-stdlib/sources/configs/features.move

@@ -781,6 +781,16 @@ module std::features {
         is_enabled(STAKE_REWARD_USING_TREASURY)
     }
 
+    /// Whether the Storage fee is refund on deletion (enable) or never refund (disable). 
+    ///
+    /// Lifetime: permanent
+    const STORAGE_DELETION_REFUND: u64 = 225;
+
+    public fun get_storage_deletion_refund_feature(): u64 { STORAGE_DELETION_REFUND }
+
+    public fun storage_deletion_refund_enabled(): bool acquires Features {
+        is_enabled(STORAGE_DELETION_REFUND)
+    }
     // ============================================================================================
     // Feature Flag Implementation