Written by
Ethereum’s self-destruction op code: a deep dive
The Virtual Machine (EVM) from Ethereum has introduced the self -cestruct opcode, which provides a mechanism to delete all memory and code from a contract and the transfer of your balance to the first argument. As you have emphasized, some aspects of implementing this EIP require further clarification.
What is self -destruction?
Self-destruction structure relates to the process of deleting the entire memory and the code from a contract in connection with Ethereum contracts if it is stopped manually by an external event. When a contract destroys itself, he fills his assets (i.e. ether) to the open market.
The self -limited opcode
The Self -Cestruct opcode was first proposed in April 2018 as part of the EIP 1557 by Ethereum. After this proposal, a contract occurs with the Opcode op code that is carried out: The following episode of events takes place:
- The contract calculates its total amount.
- If the remaining amount is larger or 30 ETH, the contract destroys all of its assets to the open market.
3 .. In addition to the publication of its assets, the contract transfers an instance of itself to an external address (e.g. an intelligent contract or a wallet).
- The first argument that was handed over to the self -limited Op code is then returned to the caller.
Implementation challenges
While the concept of self-destructive contracts in the Ethereum community was discussed in detail, its implementation remains somewhat opaque. For example:
- How does the EVM determine when a contract should destroy itself?
- What happens if a contract has not reached a residual amount, but does not arise any explicitly opcode itself?
- Can other EIPS (Ethereum improvements) inherit or change the self -desetstructure mechanism?
Diploma
The Ethereum Community refines and continues to improve the implementation of the OPCODE Selterstructs. If the protocol develops, we can expect further clarification of how this mechanism works and how it could be used in practice.
In the meantime, it is crucial to understand the basics of self-destructors contracts that are interested in creating intelligent contracts in the Ethereum network.
Code Example
In order to give you a better idea of how self -determining works, you will find an example of what a contract implementation could look like:
`Solidity
Pragma solidity ^0.8.0;
Contract friendliness {
appeal to public owners;
Uint256 public balance = 10 * (1 ether); // start balance
Event Operation Set (address holder);
Functional ornacner (address _owner) Public {
Require (_Muner! = Address (0), “Owner cannot 0x0”);
Owner = _ owner;
E -emit owners (owner);
}
Function Selfstruct () Public {
require (balance> = 30 * (1 ether), “balance must be at least 30 ETH”);
Balance -= 30 * (1 ether); // destroy yourself and release assets
Transfer (1 Ether, address (dies));
output selfcestruct ();
}
}
`
Note that this is a highly simplified example and that not all aspects of the op code yourself relax. For more precise representation, you should consult the Ethereum documentation or refer to existing contract implementations in the network.