diff --git a/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java b/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java
index 1df35154d7d..6df6ba80a80 100644
--- a/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java
+++ b/actuator/src/main/java/org/tron/core/utils/ProposalUtil.java
@@ -841,6 +841,21 @@ public static void validator(DynamicPropertiesStore dynamicPropertiesStore,
         }
         break;
       }
+      case ALLOW_TVM_SELFDESTRUCT_RESTRICTION: {
+        if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_8_1)) {
+          throw new ContractValidateException(
+              "Bad chain parameter id [ALLOW_TVM_SELFDESTRUCT_RESTRICTION]");
+        }
+        if (dynamicPropertiesStore.allowTvmSelfdestructRestriction()) {
+          throw new ContractValidateException(
+              "[ALLOW_TVM_SELFDESTRUCT_RESTRICTION] has been valid, no need to propose again");
+        }
+        if (value != 1) {
+          throw new ContractValidateException(
+              "This value[ALLOW_TVM_SELFDESTRUCT_RESTRICTION] is only allowed to be 1");
+        }
+        break;
+      }
       case PROPOSAL_EXPIRE_TIME: {
         if (!forkController.pass(ForkBlockVersionEnum.VERSION_4_8_1)) {
           throw new ContractValidateException(
@@ -938,7 +953,8 @@ public enum ProposalType {         // current value, value range
     ALLOW_STRICT_MATH(87), // 0, 1
     CONSENSUS_LOGIC_OPTIMIZATION(88), // 0, 1
     ALLOW_TVM_BLOB(89), // 0, 1
-    PROPOSAL_EXPIRE_TIME(92); // (0, 31536003000)
+    PROPOSAL_EXPIRE_TIME(92), // (0, 31536003000)
+    ALLOW_TVM_SELFDESTRUCT_RESTRICTION(94); // 0, 1
 
     private long code;
 
diff --git a/actuator/src/main/java/org/tron/core/vm/EnergyCost.java b/actuator/src/main/java/org/tron/core/vm/EnergyCost.java
index b758438c940..d47f716943f 100644
--- a/actuator/src/main/java/org/tron/core/vm/EnergyCost.java
+++ b/actuator/src/main/java/org/tron/core/vm/EnergyCost.java
@@ -55,6 +55,7 @@ public class EnergyCost {
   private static final long EXT_CODE_SIZE = 20;
   private static final long EXT_CODE_HASH = 400;
   private static final long SUICIDE = 0;
+  private static final long SUICIDE_V2 = 5000;
   private static final long STOP = 0;
   private static final long CREATE_DATA = 200;
   private static final long TLOAD = 100;
@@ -289,6 +290,14 @@ public static long getSuicideCost2(Program program) {
     return getSuicideCost(program);
   }
 
+  public static long getSuicideCost3(Program program) {
+    DataWord inheritorAddress = program.getStack().peek();
+    if (isDeadAccount(program, inheritorAddress)) {
+      return SUICIDE_V2 + NEW_ACCT_CALL;
+    }
+    return SUICIDE_V2;
+  }
+
   public static long getBalanceCost(Program ignored) {
     return BALANCE;
   }
diff --git a/actuator/src/main/java/org/tron/core/vm/OperationActions.java b/actuator/src/main/java/org/tron/core/vm/OperationActions.java
index f10fb37dd7e..0d978743a5e 100644
--- a/actuator/src/main/java/org/tron/core/vm/OperationActions.java
+++ b/actuator/src/main/java/org/tron/core/vm/OperationActions.java
@@ -1072,4 +1072,19 @@ public static void suicideAction(Program program) {
     program.stop();
   }
 
+  public static void suicideAction2(Program program) {
+    if (program.isStaticCall()) {
+      throw new Program.StaticCallModificationException();
+    }
+
+    if (!program.canSuicide2()) {
+      program.getResult().setRevert();
+    } else {
+      DataWord address = program.stackPop();
+      program.suicide2(address);
+    }
+
+    program.stop();
+  }
+
 }
diff --git a/actuator/src/main/java/org/tron/core/vm/OperationRegistry.java b/actuator/src/main/java/org/tron/core/vm/OperationRegistry.java
index be29238a775..f6140107efb 100644
--- a/actuator/src/main/java/org/tron/core/vm/OperationRegistry.java
+++ b/actuator/src/main/java/org/tron/core/vm/OperationRegistry.java
@@ -79,6 +79,10 @@ public static JumpTable getTable() {
       adjustForFairEnergy(table);
     }
 
+    if (VMConfig.allowTvmSelfdestructRestriction()) {
+      adjustSelfdestruct(table);
+    }
+
     return table;
   }
 
@@ -695,4 +699,11 @@ public static void appendCancunOperations(JumpTable table) {
         OperationActions::blobBaseFeeAction,
         tvmBlobProposal));
   }
+
+  public static void adjustSelfdestruct(JumpTable table) {
+    table.set(new Operation(
+        Op.SUICIDE, 1, 0,
+        EnergyCost::getSuicideCost3,
+        OperationActions::suicideAction2));
+  }
 }
diff --git a/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java b/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java
index 1ec8a75d669..e0ebca329cd 100644
--- a/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java
+++ b/actuator/src/main/java/org/tron/core/vm/config/ConfigLoader.java
@@ -44,6 +44,7 @@ public static void load(StoreFactory storeFactory) {
         VMConfig.initAllowTvmCancun(ds.getAllowTvmCancun());
         VMConfig.initDisableJavaLangMath(ds.getConsensusLogicOptimization());
         VMConfig.initAllowTvmBlob(ds.getAllowTvmBlob());
+        VMConfig.initAllowTvmSelfdestructRestriction(ds.getAllowTvmSelfdestructRestriction());
       }
     }
   }
diff --git a/actuator/src/main/java/org/tron/core/vm/program/ContractState.java b/actuator/src/main/java/org/tron/core/vm/program/ContractState.java
index e095201e393..c6347b9a072 100644
--- a/actuator/src/main/java/org/tron/core/vm/program/ContractState.java
+++ b/actuator/src/main/java/org/tron/core/vm/program/ContractState.java
@@ -121,6 +121,16 @@ public void updateContractState(byte[] address, ContractStateCapsule contractSta
     repository.updateContractState(address, contractStateCapsule);
   }
 
+  @Override
+  public void putNewContract(byte[] address) {
+    repository.putNewContract(address);
+  }
+
+  @Override
+  public boolean isNewContract(byte[] address) {
+    return repository.isNewContract(address);
+  }
+
   @Override
   public void updateAccount(byte[] address, AccountCapsule accountCapsule) {
     repository.updateAccount(address, accountCapsule);
diff --git a/actuator/src/main/java/org/tron/core/vm/program/Program.java b/actuator/src/main/java/org/tron/core/vm/program/Program.java
index 5da0b02ecb7..59ac8314683 100644
--- a/actuator/src/main/java/org/tron/core/vm/program/Program.java
+++ b/actuator/src/main/java/org/tron/core/vm/program/Program.java
@@ -515,6 +515,72 @@ public void suicide(DataWord obtainerAddress) {
     getResult().addDeleteAccount(this.getContractAddress());
   }
 
+  public void suicide2(DataWord obtainerAddress) {
+
+    byte[] owner = getContextAddress();
+    boolean isNewContract = getContractState().isNewContract(owner);
+    if (isNewContract) {
+      suicide(obtainerAddress);
+      return;
+    }
+
+    byte[] obtainer = obtainerAddress.toTronAddress();
+
+    long balance = getContractState().getBalance(owner);
+
+    if (logger.isDebugEnabled()) {
+      logger.debug("Transfer to: [{}] heritage: [{}]",
+          Hex.toHexString(obtainer),
+          balance);
+    }
+
+    increaseNonce();
+
+    InternalTransaction internalTx = addInternalTx(null, owner, obtainer, balance, null,
+        "suicide", nonce, getContractState().getAccount(owner).getAssetMapV2());
+
+    if (FastByteComparisons.isEqual(owner, obtainer)) {
+      return;
+    }
+
+    if (VMConfig.allowTvmVote()) {
+      withdrawRewardAndCancelVote(owner, getContractState());
+      balance = getContractState().getBalance(owner);
+      if (internalTx != null && balance != internalTx.getValue()) {
+        internalTx.setValue(balance);
+      }
+    }
+
+    // transfer balance and trc10
+    createAccountIfNotExist(getContractState(), obtainer);
+    try {
+      MUtil.transfer(getContractState(), owner, obtainer, balance);
+      if (VMConfig.allowTvmTransferTrc10()) {
+        MUtil.transferAllToken(getContractState(), owner, obtainer);
+      }
+    } catch (ContractValidateException e) {
+      if (VMConfig.allowTvmConstantinople()) {
+        throw new TransferException(
+            "transfer all token or transfer all trx failed in suicide: %s", e.getMessage());
+      }
+      throw new BytecodeExecutionException("transfer failure");
+    }
+
+    // transfer freeze
+    if (VMConfig.allowTvmFreeze()) {
+      transferDelegatedResourceToInheritor(owner, obtainer, getContractState());
+    }
+
+    // transfer freezeV2
+    if (VMConfig.allowTvmFreezeV2()) {
+      long expireUnfrozenBalance =
+          transferFrozenV2BalanceToInheritor(owner, obtainer, getContractState());
+      if (expireUnfrozenBalance > 0 && internalTx != null) {
+        internalTx.setValue(internalTx.getValue() + expireUnfrozenBalance);
+      }
+    }
+  }
+
   public Repository getContractState() {
     return this.contractState;
   }
@@ -544,6 +610,11 @@ private void transferDelegatedResourceToInheritor(byte[] ownerAddr, byte[] inher
 
     // transfer all kinds of frozen balance to BlackHole
     repo.addBalance(inheritorAddr, frozenBalanceForBandwidthOfOwner + frozenBalanceForEnergyOfOwner);
+
+    if (VMConfig.allowTvmSelfdestructRestriction()) {
+      clearOwnerFreeze(ownerCapsule);
+      repo.updateAccount(ownerAddr, ownerCapsule);
+    }
   }
 
   private long transferFrozenV2BalanceToInheritor(byte[] ownerAddr, byte[] inheritorAddr, Repository repo) {
@@ -609,6 +680,11 @@ private long transferFrozenV2BalanceToInheritor(byte[] ownerAddr, byte[] inherit
     return expireUnfrozenBalance;
   }
 
+  private void clearOwnerFreeze(AccountCapsule ownerCapsule) {
+    ownerCapsule.setFrozenForBandwidth(0, 0);
+    ownerCapsule.setFrozenForEnergy(0, 0);
+  }
+
   private void clearOwnerFreezeV2(AccountCapsule ownerCapsule) {
     ownerCapsule.clearFrozenV2();
     ownerCapsule.setNetUsage(0);
@@ -666,6 +742,38 @@ public boolean canSuicide() {
 //    return freezeCheck && voteCheck;
   }
 
+  public boolean canSuicide2() {
+    byte[] owner = getContextAddress();
+    AccountCapsule accountCapsule = getContractState().getAccount(owner);
+
+    return freezeV1Check(accountCapsule) && freezeV2Check(accountCapsule);
+  }
+
+  private boolean freezeV1Check(AccountCapsule accountCapsule) {
+    if (!VMConfig.allowTvmFreeze()) {
+      return true;
+    }
+
+    // check freeze
+    long now = getContractState().getDynamicPropertiesStore().getLatestBlockHeaderTimestamp();
+    // bandwidth
+    if (accountCapsule.getFrozenCount() > 0
+        && accountCapsule.getFrozenList().stream()
+        .anyMatch(frozen -> frozen.getExpireTime() > now)) {
+      return false;
+    }
+    // energy
+    Protocol.Account.Frozen frozenEnergy =
+        accountCapsule.getAccountResource().getFrozenBalanceForEnergy();
+    if (frozenEnergy.getFrozenBalance() > 0 && frozenEnergy.getExpireTime() > now) {
+      return false;
+    }
+
+    // check delegate
+    return accountCapsule.getDelegatedFrozenBalanceForBandwidth() == 0
+        && accountCapsule.getDelegatedFrozenBalanceForEnergy() == 0;
+  }
+
   private boolean freezeV2Check(AccountCapsule accountCapsule) {
     if (!VMConfig.allowTvmFreezeV2()) {
       return true;
diff --git a/actuator/src/main/java/org/tron/core/vm/repository/Repository.java b/actuator/src/main/java/org/tron/core/vm/repository/Repository.java
index 664ee26ee92..8f91d59d0b8 100644
--- a/actuator/src/main/java/org/tron/core/vm/repository/Repository.java
+++ b/actuator/src/main/java/org/tron/core/vm/repository/Repository.java
@@ -55,6 +55,10 @@ public interface Repository {
 
   void updateContractState(byte[] address, ContractStateCapsule contractStateCapsule);
 
+  void putNewContract(byte[] address);
+
+  boolean isNewContract(byte[] address);
+
   void updateAccount(byte[] address, AccountCapsule accountCapsule);
 
   void updateDynamicProperty(byte[] word, BytesCapsule bytesCapsule);
diff --git a/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java b/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java
index a064cbf6c8a..9de7c0691ba 100644
--- a/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java
+++ b/actuator/src/main/java/org/tron/core/vm/repository/RepositoryImpl.java
@@ -9,6 +9,7 @@
 import com.google.common.collect.HashBasedTable;
 import com.google.protobuf.ByteString;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Optional;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
@@ -135,6 +136,7 @@ public class RepositoryImpl implements Repository {
   private final HashMap<Key, Value<byte[]>> delegationCache = new HashMap<>();
   private final HashMap<Key, Value<DelegatedResourceAccountIndex>> delegatedResourceAccountIndexCache = new HashMap<>();
   private final HashBasedTable<Key, Key, Value<byte[]>> transientStorage = HashBasedTable.create();
+  private final HashSet<Key> newContractCache = new HashSet<>();
 
   public static void removeLruCache(byte[] address) {
   }
@@ -479,6 +481,7 @@ public void deleteContract(byte[] address) {
   public void createContract(byte[] address, ContractCapsule contractCapsule) {
     contractCache.put(Key.create(address),
         Value.create(contractCapsule, Type.CREATE));
+    putNewContract(address);
   }
 
   @Override
@@ -533,6 +536,29 @@ public void updateContractState(byte[] address, ContractStateCapsule contractSta
         Value.create(contractStateCapsule, Type.DIRTY));
   }
 
+  @Override
+  public void putNewContract(byte[] address) {
+    newContractCache.add(Key.create(address));
+  }
+
+  @Override
+  public boolean isNewContract(byte[] address) {
+    Key key = Key.create(address);
+    if (newContractCache.contains(key)) {
+      return true;
+    }
+
+    if (parent != null) {
+      boolean isNew = parent.isNewContract(address);
+      if (isNew) {
+        newContractCache.add(key);
+      }
+      return isNew;
+    } else {
+      return false;
+    }
+  }
+
   @Override
   public void updateAccount(byte[] address, AccountCapsule accountCapsule) {
     accountCache.put(Key.create(address),
@@ -740,6 +766,7 @@ public void commit() {
     commitDelegationCache(repository);
     commitDelegatedResourceAccountIndexCache(repository);
     commitTransientStorage(repository);
+    commitNewContractCache(repository);
   }
 
   @Override
@@ -1060,6 +1087,12 @@ public void commitTransientStorage(Repository deposit) {
     }
   }
 
+  public void commitNewContractCache(Repository deposit) {
+    if (deposit != null) {
+      newContractCache.forEach(key -> deposit.putNewContract(key.getData()));
+    }
+  }
+
   /**
    * Get the block id from the number.
    */
diff --git a/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java b/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java
index bee13782e53..91e8723bd28 100644
--- a/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java
+++ b/chainbase/src/main/java/org/tron/core/store/DynamicPropertiesStore.java
@@ -235,6 +235,9 @@ public class DynamicPropertiesStore extends TronStoreWithRevoking<BytesCapsule>
   private static final byte[] ALLOW_TVM_BLOB = "ALLOW_TVM_BLOB".getBytes();
   private static final byte[] PROPOSAL_EXPIRE_TIME = "PROPOSAL_EXPIRE_TIME".getBytes();
 
+  private static final byte[] ALLOW_TVM_SELFDESTRUCT_RESTRICTION =
+      "ALLOW_TVM_SELFDESTRUCT_RESTRICTION".getBytes();
+
   @Autowired
   private DynamicPropertiesStore(@Value("properties") String dbName) {
     super(dbName);
@@ -2949,6 +2952,22 @@ public long getAllowTvmBlob() {
         .orElse(CommonParameter.getInstance().getAllowTvmBlob());
   }
 
+
+  public long getAllowTvmSelfdestructRestriction() {
+    return Optional.ofNullable(getUnchecked(ALLOW_TVM_SELFDESTRUCT_RESTRICTION))
+        .map(BytesCapsule::getData)
+        .map(ByteArray::toLong)
+        .orElse(CommonParameter.getInstance().getAllowTvmSelfdestructRestriction());
+  }
+
+  public void saveAllowTvmSelfdestructRestriction(long value) {
+    this.put(ALLOW_TVM_SELFDESTRUCT_RESTRICTION, new BytesCapsule(ByteArray.fromLong(value)));
+  }
+
+  public boolean allowTvmSelfdestructRestriction() {
+    return getAllowTvmSelfdestructRestriction() == 1L;
+  }
+  
   public void saveProposalExpireTime(long proposalExpireTime) {
     this.put(PROPOSAL_EXPIRE_TIME, new BytesCapsule(ByteArray.fromLong(proposalExpireTime)));
   }
diff --git a/common/src/main/java/org/tron/common/parameter/CommonParameter.java b/common/src/main/java/org/tron/common/parameter/CommonParameter.java
index e32708a77e6..9e8c3682e66 100644
--- a/common/src/main/java/org/tron/common/parameter/CommonParameter.java
+++ b/common/src/main/java/org/tron/common/parameter/CommonParameter.java
@@ -741,6 +741,10 @@ public class CommonParameter {
   @Setter
   public long allowTvmBlob;
 
+  @Getter
+  @Setter
+  public long allowTvmSelfdestructRestriction;
+
   private static double calcMaxTimeRatio() {
     //return max(2.0, min(5.0, 5 * 4.0 / max(Runtime.getRuntime().availableProcessors(), 1)));
     return 5.0;
diff --git a/common/src/main/java/org/tron/core/Constant.java b/common/src/main/java/org/tron/core/Constant.java
index 824373b1328..3d5c56dbbf0 100644
--- a/common/src/main/java/org/tron/core/Constant.java
+++ b/common/src/main/java/org/tron/core/Constant.java
@@ -418,5 +418,10 @@ public class Constant {
   public static final String COMMITTEE_ALLOW_TVM_CANCUN = "committee.allowTvmCancun";
 
   public static final String COMMITTEE_ALLOW_TVM_BLOB = "committee.allowTvmBlob";
+
+  public static final String COMMITTEE_ALLOW_TVM_SELFDESTRUCT_RESTRICTION =
+      "committee.allowTvmSelfdestructRestriction";
+
   public static final String COMMITTEE_PROPOSAL_EXPIRE_TIME = "committee.proposalExpireTime";
+
 }
diff --git a/common/src/main/java/org/tron/core/vm/config/VMConfig.java b/common/src/main/java/org/tron/core/vm/config/VMConfig.java
index 2bdbeb78b92..578827b2f8c 100644
--- a/common/src/main/java/org/tron/core/vm/config/VMConfig.java
+++ b/common/src/main/java/org/tron/core/vm/config/VMConfig.java
@@ -59,6 +59,8 @@ public class VMConfig {
 
   private static boolean ALLOW_TVM_BLOB = false;
 
+  private static boolean ALLOW_TVM_SELFDESTRUCT_RESTRICTION = false;
+
   private VMConfig() {
   }
 
@@ -166,6 +168,10 @@ public static void initAllowTvmBlob(long allow) {
     ALLOW_TVM_BLOB = allow == 1;
   }
 
+  public static void initAllowTvmSelfdestructRestriction(long allow) {
+    ALLOW_TVM_SELFDESTRUCT_RESTRICTION = allow == 1;
+  }
+
   public static boolean getEnergyLimitHardFork() {
     return CommonParameter.ENERGY_LIMIT_HARD_FORK;
   }
@@ -261,4 +267,8 @@ public static boolean disableJavaLangMath() {
   public static boolean allowTvmBlob() {
     return ALLOW_TVM_BLOB;
   }
+
+  public static boolean allowTvmSelfdestructRestriction() {
+    return ALLOW_TVM_SELFDESTRUCT_RESTRICTION;
+  }
 }
diff --git a/framework/src/main/java/org/tron/core/Wallet.java b/framework/src/main/java/org/tron/core/Wallet.java
index 125443d59dd..eb8f4b832d2 100755
--- a/framework/src/main/java/org/tron/core/Wallet.java
+++ b/framework/src/main/java/org/tron/core/Wallet.java
@@ -1387,6 +1387,11 @@ public Protocol.ChainParameters getChainParameters() {
         .setValue(dbManager.getDynamicPropertiesStore().getAllowTvmBlob())
         .build());
 
+    builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()
+        .setKey("getAllowTvmSelfdestructRestriction")
+        .setValue(dbManager.getDynamicPropertiesStore().getAllowTvmSelfdestructRestriction())
+        .build());                      
+    
     builder.addChainParameter(Protocol.ChainParameters.ChainParameter.newBuilder()
         .setKey("getProposalExpireTime")
         .setValue(dbManager.getDynamicPropertiesStore().getProposalExpireTime())
diff --git a/framework/src/main/java/org/tron/core/config/args/Args.java b/framework/src/main/java/org/tron/core/config/args/Args.java
index 92a021280c4..f3e8a2ed790 100644
--- a/framework/src/main/java/org/tron/core/config/args/Args.java
+++ b/framework/src/main/java/org/tron/core/config/args/Args.java
@@ -250,6 +250,7 @@ public static void clearParam() {
     PARAMETER.consensusLogicOptimization = 0;
     PARAMETER.allowTvmCancun = 0;
     PARAMETER.allowTvmBlob = 0;
+    PARAMETER.allowTvmSelfdestructRestriction = 0;
   }
 
   /**
@@ -1262,6 +1263,10 @@ public static void setParam(final Config config) {
         config.hasPath(Constant.COMMITTEE_ALLOW_TVM_BLOB) ? config
             .getInt(Constant.COMMITTEE_ALLOW_TVM_BLOB) : 0;
 
+    PARAMETER.allowTvmSelfdestructRestriction =
+        config.hasPath(Constant.COMMITTEE_ALLOW_TVM_SELFDESTRUCT_RESTRICTION) ? config
+            .getInt(Constant.COMMITTEE_ALLOW_TVM_SELFDESTRUCT_RESTRICTION) : 0;
+
     logConfig();
   }
 
diff --git a/framework/src/main/java/org/tron/core/consensus/ProposalService.java b/framework/src/main/java/org/tron/core/consensus/ProposalService.java
index d6cf0e5fe67..51d53f6a59e 100644
--- a/framework/src/main/java/org/tron/core/consensus/ProposalService.java
+++ b/framework/src/main/java/org/tron/core/consensus/ProposalService.java
@@ -384,6 +384,10 @@ public static boolean process(Manager manager, ProposalCapsule proposalCapsule)
           manager.getDynamicPropertiesStore().saveAllowTvmBlob(entry.getValue());
           break;
         }
+        case ALLOW_TVM_SELFDESTRUCT_RESTRICTION: {
+          manager.getDynamicPropertiesStore().saveAllowTvmSelfdestructRestriction(entry.getValue());
+          break;
+        }
         case PROPOSAL_EXPIRE_TIME: {
           manager.getDynamicPropertiesStore().saveProposalExpireTime(entry.getValue());
           break;
diff --git a/framework/src/test/java/org/tron/common/ParameterTest.java b/framework/src/test/java/org/tron/common/ParameterTest.java
index b16be405f61..03fdf462b26 100644
--- a/framework/src/test/java/org/tron/common/ParameterTest.java
+++ b/framework/src/test/java/org/tron/common/ParameterTest.java
@@ -316,5 +316,7 @@ public void testCommonParameter() {
     assertEquals(1, parameter.getAllowEnergyAdjustment());
     parameter.setMaxCreateAccountTxSize(1000);
     assertEquals(1000, parameter.getMaxCreateAccountTxSize());
+    parameter.setAllowTvmSelfdestructRestriction(1);
+    assertEquals(1, parameter.getAllowTvmSelfdestructRestriction());
   }
 }
diff --git a/framework/src/test/java/org/tron/common/runtime/vm/OperationsTest.java b/framework/src/test/java/org/tron/common/runtime/vm/OperationsTest.java
index 3315005b7d2..b447af87bc2 100644
--- a/framework/src/test/java/org/tron/common/runtime/vm/OperationsTest.java
+++ b/framework/src/test/java/org/tron/common/runtime/vm/OperationsTest.java
@@ -1,6 +1,8 @@
 package org.tron.common.runtime.vm;
 
 import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.tron.core.config.Parameter.ChainConstant.FROZEN_PERIOD;
 
 import java.util.List;
 import java.util.Random;
@@ -13,12 +15,14 @@
 import org.junit.BeforeClass;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.mockito.Mockito;
 import org.springframework.util.StringUtils;
 import org.tron.common.BaseTest;
 import org.tron.common.parameter.CommonParameter;
 import org.tron.common.runtime.InternalTransaction;
 import org.tron.common.utils.DecodeUtil;
 import org.tron.core.Constant;
+import org.tron.core.capsule.AccountCapsule;
 import org.tron.core.config.args.Args;
 import org.tron.core.exception.ContractValidateException;
 import org.tron.core.store.StoreFactory;
@@ -26,12 +30,14 @@
 import org.tron.core.vm.JumpTable;
 import org.tron.core.vm.Op;
 import org.tron.core.vm.Operation;
+import org.tron.core.vm.OperationActions;
 import org.tron.core.vm.OperationRegistry;
 import org.tron.core.vm.VM;
 import org.tron.core.vm.config.ConfigLoader;
 import org.tron.core.vm.config.VMConfig;
 import org.tron.core.vm.program.Program;
 import org.tron.core.vm.program.invoke.ProgramInvokeMockImpl;
+import org.tron.core.vm.repository.Repository;
 import org.tron.protos.Protocol;
 
 @Slf4j
@@ -886,6 +892,12 @@ public void testSuicideCost() throws ContractValidateException {
     Assert.assertEquals(25000, EnergyCost.getSuicideCost2(program));
     invoke.getDeposit().createAccount(receiver2, Protocol.AccountType.Normal);
     Assert.assertEquals(0, EnergyCost.getSuicideCost2(program));
+
+    byte[] receiver3 = generateRandomAddress();
+    program.stackPush(new DataWord(receiver3));
+    Assert.assertEquals(30000, EnergyCost.getSuicideCost3(program));
+    invoke.getDeposit().createAccount(receiver3, Protocol.AccountType.Normal);
+    Assert.assertEquals(5000, EnergyCost.getSuicideCost3(program));
   }
 
   @Test
@@ -911,6 +923,85 @@ public void testSuicideAction() throws ContractValidateException {
     VMConfig.initAllowEnergyAdjustment(0);
   }
 
+  @Test
+  public void testCanSuicide2() throws ContractValidateException {
+    VMConfig.initAllowTvmFreeze(1);
+    VMConfig.initAllowTvmFreezeV2(1);
+
+    byte[] contractAddr = Hex.decode("41471fd3ad3e9eeadeec4608b92d16ce6b500704cc");
+    invoke = new ProgramInvokeMockImpl(StoreFactory.getInstance(), new byte[0], contractAddr);
+
+    program = new Program(null, null, invoke,
+        new InternalTransaction(
+            Protocol.Transaction.getDefaultInstance(),
+            InternalTransaction.TrxType.TRX_UNKNOWN_TYPE));
+    program.getContractState().createAccount(
+        program.getContextAddress(), Protocol.AccountType.Contract);
+    Assert.assertTrue(program.canSuicide2());
+
+    long nowInMs =
+        program.getContractState().getDynamicPropertiesStore().getLatestBlockHeaderTimestamp();
+    long expireTime = nowInMs + FROZEN_PERIOD;
+    AccountCapsule owner = program.getContractState().getAccount(program.getContextAddress());
+    owner.setFrozenForEnergy(1000000, expireTime);
+    program.getContractState().updateAccount(program.getContextAddress(), owner);
+    Assert.assertFalse(program.canSuicide2());
+
+    VMConfig.initAllowTvmFreeze(0);
+    VMConfig.initAllowTvmFreezeV2(0);
+  }
+
+  @Test
+  public void testSuicideAction2() throws ContractValidateException {
+    byte[] contractAddr = Hex.decode("41471fd3ad3e9eeadeec4608b92d16ce6b500704cc");
+    invoke = new ProgramInvokeMockImpl(StoreFactory.getInstance(), new byte[0], contractAddr);
+    Assert.assertTrue(invoke.getDeposit().isNewContract(contractAddr));
+
+    program = new Program(null, null, invoke,
+        new InternalTransaction(
+            Protocol.Transaction.getDefaultInstance(),
+            InternalTransaction.TrxType.TRX_UNKNOWN_TYPE));
+
+    VMConfig.initAllowEnergyAdjustment(1);
+    VMConfig.initAllowTvmSelfdestructRestriction(1);
+    VMConfig.initAllowTvmFreeze(1);
+    VMConfig.initAllowTvmFreezeV2(1);
+    VMConfig.initAllowTvmCompatibleEvm(1);
+    VMConfig.initAllowTvmVote(1);
+    byte prePrefixByte = DecodeUtil.addressPreFixByte;
+    DecodeUtil.addressPreFixByte = Constant.ADD_PRE_FIX_BYTE_MAINNET;
+
+    program.stackPush(new DataWord(
+            dbManager.getAccountStore().getBlackhole().getAddress().toByteArray()));
+    OperationActions.suicideAction2(program);
+
+    Assert.assertEquals(1, program.getResult().getDeleteAccounts().size());
+
+
+    invoke = new ProgramInvokeMockImpl(StoreFactory.getInstance(), new byte[0], contractAddr);
+    program = new Program(null, null, invoke,
+        new InternalTransaction(
+            Protocol.Transaction.getDefaultInstance(),
+            InternalTransaction.TrxType.TRX_UNKNOWN_TYPE));
+    Program spyProgram = Mockito.spy(program);
+    Repository realContractState = program.getContractState();
+    Repository spyContractState = Mockito.spy(realContractState);
+    Mockito.when(spyContractState.isNewContract(any(byte[].class))).thenReturn(false);
+    Mockito.when(spyProgram.getContractState()).thenReturn(spyContractState);
+    spyProgram.suicide2(new DataWord(
+        dbManager.getAccountStore().getBlackhole().getAddress().toByteArray()));
+
+    Assert.assertEquals(0, spyProgram.getResult().getDeleteAccounts().size());
+
+    DecodeUtil.addressPreFixByte = prePrefixByte;
+    VMConfig.initAllowEnergyAdjustment(0);
+    VMConfig.initAllowTvmSelfdestructRestriction(0);
+    VMConfig.initAllowTvmFreeze(0);
+    VMConfig.initAllowTvmFreezeV2(0);
+    VMConfig.initAllowTvmCompatibleEvm(0);
+    VMConfig.initAllowTvmVote(0);
+  }
+
   @Test
   public void testVoteWitnessCost() throws ContractValidateException {
     // Build stack environment, the stack from top to bottom is 0x00, 0x80, 0x00, 0x80
diff --git a/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java b/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java
index e8a1e862f54..d83f7f14e29 100644
--- a/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java
+++ b/framework/src/test/java/org/tron/core/actuator/utils/ProposalUtilTest.java
@@ -439,6 +439,8 @@ public void validateCheck() {
 
     testAllowTvmBlobProposal();
 
+    testAllowTvmSelfdestructRestrictionProposal();
+
     forkUtils.getManager().getDynamicPropertiesStore()
         .statsByVersion(ForkBlockVersionEnum.ENERGY_LIMIT.getValue(), stats);
     forkUtils.reset();
@@ -659,6 +661,58 @@ private void testAllowTvmBlobProposal() {
 
   }
 
+  private void testAllowTvmSelfdestructRestrictionProposal() {
+    byte[] stats = new byte[27];
+    forkUtils.getManager().getDynamicPropertiesStore()
+        .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_1.getValue(), stats);
+    try {
+      ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+          ProposalType.ALLOW_TVM_SELFDESTRUCT_RESTRICTION.getCode(), 1);
+      Assert.fail();
+    } catch (ContractValidateException e) {
+      Assert.assertEquals(
+          "Bad chain parameter id [ALLOW_TVM_SELFDESTRUCT_RESTRICTION]",
+          e.getMessage());
+    }
+
+    long maintenanceTimeInterval = forkUtils.getManager().getDynamicPropertiesStore()
+        .getMaintenanceTimeInterval();
+
+    long hardForkTime =
+        ((ForkBlockVersionEnum.VERSION_4_8_1.getHardForkTime() - 1) / maintenanceTimeInterval + 1)
+            * maintenanceTimeInterval;
+    forkUtils.getManager().getDynamicPropertiesStore()
+        .saveLatestBlockHeaderTimestamp(hardForkTime + 1);
+
+    stats = new byte[27];
+    Arrays.fill(stats, (byte) 1);
+    forkUtils.getManager().getDynamicPropertiesStore()
+        .statsByVersion(ForkBlockVersionEnum.VERSION_4_8_1.getValue(), stats);
+
+    // Should fail because the proposal value is invalid
+    try {
+      ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+          ProposalType.ALLOW_TVM_SELFDESTRUCT_RESTRICTION.getCode(), 2);
+      Assert.fail();
+    } catch (ContractValidateException e) {
+      Assert.assertEquals(
+          "This value[ALLOW_TVM_SELFDESTRUCT_RESTRICTION] is only allowed to be 1",
+          e.getMessage());
+    }
+
+    dynamicPropertiesStore.saveAllowTvmSelfdestructRestriction(1);
+    try {
+      ProposalUtil.validator(dynamicPropertiesStore, forkUtils,
+          ProposalType.ALLOW_TVM_SELFDESTRUCT_RESTRICTION.getCode(), 1);
+      Assert.fail();
+    } catch (ContractValidateException e) {
+      Assert.assertEquals(
+          "[ALLOW_TVM_SELFDESTRUCT_RESTRICTION] has been valid, no need to propose again",
+          e.getMessage());
+    }
+
+  }
+
   @Test
   public void blockVersionCheck() {
     for (ForkBlockVersionEnum forkVersion : ForkBlockVersionEnum.values()) {