¿Por qué se utilizan autodestrucciones en la programación de contratos?

Las autodestrucciones en Ethereum son una operación (un OPCODE en realidad) a nivel de EVM, independientemente del idioma o cliente que esté utilizando.

Por ejemplo, al llamar selfdestruct(address)se envía todo el saldo actual del contrato a address.

Esto es útil cuando haya terminado con un contrato, porque cuesta mucho menos gasolina que simplemente enviar el saldo con address.send(this.balance).

De hecho, el código de operación SELFDESTRUCT usa gas negativo porque la operación libera espacio en la cadena de bloques al borrar todos los datos del contrato.

Este gas negativo se deduce del costo total de gas de la transacción, por lo que si primero está realizando algunas operaciones de limpieza, SELFDESTRUCT puede reducir sus costos de gas.

Nota: esta pregunta originalmente se refería al suicidecódigo de operación, que mientras tanto se ha convertido selfdestructen EIP6 .

selfdestructes el término recomendado y se puede encontrar en el código más nuevo de Solidity y Serpent. Es la misma API y comportamiento, como se describe en las otras respuestas, y es un alias para suicide.

EIP6 describe la motivación:

La razón principal por la que cambiamos el término suicidio es para mostrar que las personas importan más que el código y Ethereum es un proyecto lo suficientemente maduro como para reconocer la necesidad de un cambio. El suicidio es un tema pesado y debemos hacer todos los esfuerzos posibles para no afectar a aquellos en nuestra comunidad de desarrollo que sufren de depresión o que recientemente han perdido a alguien por suicidio.

La selfdestruct()función y el OPCODE relativo se utilizan cuando tiene un contrato que tiene un error o un comportamiento no deseado y desea deshacerse de él.

Es selfdestruct(address)una versión mejor, como señaló @tjaden-hess, cuando tiene contratos pagaderos (contratos que reciben éteres), los éteres se redirigirán a addresslo que es una gran ganancia.

Cuando interactúa con un contrato autodestruido, TENGA EN CUENTA esto: si le envía una transacción y/o fondos, sus fondos se PERDERÁN . Asegúrese de no enviarle fondos u otras transacciones después de autodestruir un contrato.

Ese es un problema que siempre debe tener en cuenta al desarrollar aplicaciones que usan contratos con una función de autodestrucción, asegúrese de que la dirección del contrato se elimine de su aplicación después de que selfdestruct()se haya llamado al contrato, tal vez siempre pueda llamar a un método getter para ver si el contrato responde con un valor válido antes de enviar una transacción y/o transferirle ethers.

Actualizar

El nombre del método es now selfdestruct. Tenemos alguna descripción en los nuevos documentos de solidity .

Aquí hay una publicación de r/ethereum sobre el suicidio con más información y una pequeña discusión al respecto.

En mi humilde opinión selfdestruct, es algo malo que nunca debería introducirse. Rompe el principio de inmutabilidad del contrato e introduce muchos problemas:

1. Permite enviar ether con éxito al contrato que intenta deshabilitar la transferencia de ether entrante (no tiene funciones pagables)
2. Si permite enviar ether a un contrato que intenta reaccionar activamente a las transferencias de ether entrantes, de tal manera que el contrato no notará la transferencia.
3. Si bien envía todo el éter del saldo del contrato a la dirección especificada, no envía tokens ni otros activos.
4. Los activos enviados a un contrato después selfdestructse pierden en la mayoría de los casos, verificar que el contrato no se autodestruya antes de la transferencia no ayuda mucho, porque la transferencia puede adelantarse conselfdestruct
5. Permite modificar bytecode de un contrato inteligente desplegado ( EIP-1014 )

¿Por qué se selfdestructsutilizan en la programación de contratos ?

Una vez que se crea un contrato en la cadena de bloques de Ethereum, no se puede modificar.

1. Cada bloque en la cadena de bloques se compromete con todas las transacciones en el bloque y el orden en que se encuentran. Lo hace al incluir el hash de todas las transacciones en el encabezado del bloque, que luego es parte de los datos que se codifican para la prueba de trabajo.
2. La modificación de un contrato inteligente en un bloque cambiará el hash de todas las transacciones, lo que finalmente cambia el hash del encabezado del bloque. Es probable que esto haga que el hash del encabezado del bloque tenga una prueba de trabajo no válida. Por lo tanto, para modificar la transacción, tendría que rehacer la prueba de trabajo del bloque, es decir, volver a minar el bloque.
3. Además, el encabezado del bloque incluye el hash del bloque anterior. Entonces, si desea cambiar una transacción que eventualmente contenga el contrato inteligente, también deberá volver a eliminar todos los bloques que siguen al bloque que contiene la transacción (contrato inteligente) que modificó. Por último, su conjunto de bloques modificados es en realidad una bifurcación de blockchain. Para que el resto de la red lo acepte, su bifurcación deberá tener más trabajo acumulativo que la cadena de bloques actual, lo que significa que su bifurcación debe ser más larga que la cadena de bloques actual.

BENEFICIOS DE UTILIZAR AUTODESTRUCCIÓN

+-----------------+---------------------------------------------------------------------------------------+
|     Benefit     |                                       Reasoning                                       |
+-----------------+---------------------------------------------------------------------------------------+
| Stop Execution  | If you no longer want the contract running, you can selfdestruct it to “turn it off”. |
| Eliminate Bugs  | (Similar to above). You can kill off smart contracts that are buggy.                  |
| Lower Gas Price | It costs less gas to selfdestruct a contract.                                         |
+-----------------+---------------------------------------------------------------------------------------+