Tipos de almacenamiento de datos: memory, storage y call data

Clase 11 de 21 • Curso de Introducción al Desarrollo Blockchain: Smart Contracts

Resumen

Las variables pueden tener una ubicación distinta dentro de su almacenamiento en el contrato dependiendo del uso que se les vaya a dar y cómo se utilicen.

Tipos de almacenamiento de datos

Para especificar la localización de los datos en un contrato, veremos a continuación tres posibilidades y dependiendo la misma, una variable tendrá un comportamiento u otro.

`Storage`

Indica que una variable será guardada dentro de la Blockchain. Siempre podremos obtener un valor desde el storage dado que todo en Blockchain es inmutable. A este tipo de memoria se le conoce como memoria persistente.

`Memory`

Las variables del tipo memory solo pueden ser usadas mientras se llama a una función. Después de esto, la misma se borrará. Este tipo de variable puede modificarse mientras está en uso.

`Calldata`

Similar a memory, con la diferencia de que aquí las variables no se pueden modificar mientras estén en uso. Si se sabe de antemano que una variable no necesitará modificarse, es buena práctica usar calldata para reducir el consumo de gas.

Por defecto, las variables de estado del contrato son guardadas en el storage, mientras que los parámetros de una función son guardados en memory. Los únicos tipos de datos a los que se les puede asignar un almacenamiento distinto son los tipos string, array, struct y mapping.

El tipo de almacenamiento de una variable cambiará el ciclo de vida de la misma. Haciendo que esta sea modificable o persistente dentro del contrato. Es muy importante entender la diferencia entre cada tipo para saber cuándo es conveniente utilizar cada uno y mejorar el rendimiento de un contrato.

Contribución creada por: Luis Enrique Herrera y Kevin Fiorentino (Platzi Contributors).

Andres Omar Carreon Diaz

student•

Copien y peguen el siguiente código en remix si necesitan apoyo visual. Espero que las notas les sirvan de mucho

// SPDX-License-Identifier: GPL-3.0
 pragma solidity >=0.7.0 <0.9.0;
 
 contract platziProject{
     //Aqui creamos nuestras variables
     bool isFundable;
     uint256 Goal; 
     uint256 totalFunded;
     address owner;
     uint256 requiredFunds;
     
     //Inicializamoslos valores, hay que recordar que el constructor se ejecuta solo una vez cuando se crea el contrato
     constructor(){
         Goal = 0;
         owner = msg.sender;
         totalFunded = 0;
         isFundable = true;
     }
     //No te  preocupes por esto,luego loaprenderemos. El modifier permite cambiar el comppoprtamiento de funciones, ene ste caso solo queria asegurarme que solo el creador del contrato pudiera mover el Goal
     modifier onlyOwner{
         require(msg.sender == owner, "You need to be thhe owner from this contract to change the goal");
         _;
     }
     //Aqui ponemos la meta a recaudar,solamente el que iniciaiza el contrato puede cambiar este valor
     function setGoal(uint256 goal) public onlyOwner {
         Goal = goal;
     }
     
     function viewGoal() public view returns(uint256) {
         return Goal;
     }
     
     function changeProjectState(bool change)public onlyOwner{
         isFundable = change;
     }
     //Aqui inicia la funcion para fondear el proyecto
     function fundproject() public payable {
         //Primero evaluamos si el owner del contrato mantiene abiertas las donaciones (tal vez necesita reevaluar algo)
         require(isFundable, "Owner has decided to stop this fundraising for a while. Stay tuned");
         //Comprobamos que el total que se ha fondeado sea menor a la meta
         require(totalFunded < Goal, "Goal already achieved so you are  not able to fund this anymore");
         //Despues nos aeguramos que la persona mande un minimo,en este caso arriba de 0
         require(msg.value != uint(0), "Please add some funds to  contribuite to Platzi project");
         //Comprobamos que el valor que quiere fondear no exceda con a meta que tenemos
         require(totalFunded + msg.value <= Goal,"unable to add more funds, check amount remaining for our goal");
         //Actualizamos el total que se ha fondeado al contrato
         totalFunded += msg.value;
     }
     //Esta funcion nos sirve para que lla persona pueda ver cuanto se necesita para alcanzar la meta, asi no tendra que estar adivinando cuanto depositar maximo
     function viewRemaining() public view returns(uint256){
         uint256 remainingFunds = Goal - totalFunded;
         return remainingFunds;
     }
     
 }

Pablo Palacios

student•

Muy bueno. Gracias por poner ejemplos de require - parece ser la forma de prevenir "errores" de lógica devolviendo un mensaje que indica el fallo cometido por el sender de la tx

Alexis Lozano Terán

student•

Quizas el mensaje de error que retorna onlyOwner lo cambiaria ya que no solamente se usa para setGoal, si no tambien para changeProjectState.

Daniel Buitrago

student•

Data Location

Storage: Queda guardada dentro de la blockchain, siempre vamos a poder obtener el valor almacenado, pues este nunca se va borrar. Memoria Persistente.
Memory (Modificable): Solo existe mientras se llama una función y no podemos acceder de nuevo a el dato.
Call data (inmodificable): Solo existe mientras se llama la función
Por defecto las variables de estado se almacenan en el storage y los parámetros en memory.

Jean Nuñez

student•

gracias amigo buen aporte

Juan Christopher

student•

Buen aporte.

Pepe Sosa

student•

Les dejo una cheatsheet que encontré, trae datos útiles.

Cristhian Vera Nieto

student•

exelente

Juan Christopher

student•

Gracias, maquina.

Cristopher Adasme

student•

Estuve un par de dias haciendo el desafio #1 pero aqui esta el resultado!!

// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;

contract CrowdFunding {
    string projectName;
    string projectDescription;
    uint256 goal;
    bool isActive;
    uint currentFunds;
    address payable ownerWallet;
    address owner;
    
    constructor(string memory _projectName, string memory _projectDescription, uint256 _goal) {
        projectName = _projectName;
        projectDescription = _projectDescription;
        goal = _goal;
        currentFunds = 0;
        isActive = true;
        
        // Owner Information
        ownerWallet = payable(msg.sender);
        owner = msg.sender;
    }

    function sendFunds() public payable {
        require(isActive == true, "Current project is not available!");
        ownerWallet.transfer(msg.value);
        currentFunds += msg.value;
    }

    function changeFundStatus() public {
        require(owner == msg.sender, "You must be the project owner!");
        isActive = !isActive;        
    }

    
    function getGoal() public view returns(uint) {
        return goal;
    }
    
    function getStatus() public view returns(bool) {
        return isActive;
    }
    
    function getFunds() public view returns (uint) {
        return currentFunds;
    }
}

Javier Arley Sanchez Ledesma

student•

con este ejercicio intento hacer que desarrolle la mecanica del reto,m pero al moemento de desplegar y realizar las pruebas no logro identificar como es el funcionamiento.. me pueden explicar .. !

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract Fund {
    int idProyecto;
    string nameProyecto;
    uint256 objetivoFondos;
    bool recibeFondos;
    address payable autor;
    uint256 fund;
    
    constructor (int _idProyecto, string memory _nameProyecto, uint256 _objetivoFondos){
        idProyecto = _idProyecto;
        nameProyecto=_nameProyecto;
        objetivoFondos = _objetivoFondos;
        autor = payable(msg.sender);
        recibeFondos = true;
    }
    
    function fundProyect () public payable {
        if (recibeFondos){
            autor.transfer (msg.value);
            fund += msg.value;    
        } 
    }
    
    function changeFundProyect () public payable {
        if (msg.value > objetivoFondos) {
            recibeFondos = false;
        }
        
    }

}```

Andres Felipe Pardo Mesa

student•

El funcionamiento que debería tener este smart contract debería ser:

Un usuario (wallet) puede desplegar el smart contract añadiendo la información de su proyecto (para esto usamos las variables de estado)
Un usuario (wallet) puede hacer aportes de ether al proyecto
El autor del proyecto (wallet que despliega el contrato) debe poder cambiar el estado del proyecto,si recibe o no fondos, cuando lo desee Si tu smart contract cumple con esto esta todo 👌

Mario Eduardo Contreras Serrano

student•

Actualmente no se recomienda usar transfer para enviar ETH, en cambio es mucho mejor hacer uso de call 🧐 . Les dejo por acá las referencias 👇🏻 https://medium.com/coinmonks/solidity-transfer-vs-send-vs-call-function-64c92cfc878a https://solidity-by-example.org/sending-ether/ https://blog.soliditylang.org/2020/03/26/fallback-receive-split/ https://blockchain-academy.hs-mittweida.de/courses/solidity-coding-beginners-to-intermediate/lessons/solidity-2-sending-ether-receiving-ether-emitting-events/topic/sending-ether-send-vs-transfer-vs-call/

Javier Flores

student•

Hola, leyendo un poco los aportes veo que el constructor solo se ejecuta cuando se despliega el contrato la primera vez.

Es decir que si lo pongo productivo, el msg.sender seria yo (mi wallet) y si pusiera el valor de msg.sender en una variable de estado ( owner = msg.sender) este valor quedaria asi para siempre.

Luego si desde otra wallet alguien quisiera ejecutar el contrato, ya el codigo del constructor no se ejecutaria por lo cual el valor en la variable owner seguiria siendo la mia.

Esto es correcto? no me queda claro el comportamiento.

Andres Felipe Pardo Mesa

student•

Así es, la variable global msg en el constructor va a tener la información de la wallet de quién esta haciendo deploy del contrato, al guardar estos valores en una variable de estado (storage), la variable siempre va a tener el mismo valor independientemente de si otra wallet esta consultando la variable

Bramucci Candela

student•

Resolví el reto como muestro abajo. Sin embargo, no veo que la wallet del owner gane fondos/ether ¿Me estoy olvidando de algo?

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract CreateProject {
    string public name;
    bool public isActive;
    address public owner;
    address payable ownerWallet;
    uint public totalFounded;

    constructor(string memory _name, bool _isActive){
        name = _name;
        isActive = _isActive;
        owner = msg.sender;
        ownerWallet = payable(msg.sender);
        totalFounded = 0;
    }

    function fundProject() public payable {
        if(isActive){
            ownerWallet.transfer(msg.value);
            totalFounded += msg.value;
        }
    }

    function changeProjectState(bool _newState) public{
        isActive = _newState;
    }
}

Andres Felipe Pardo Mesa

student•

Te falta agregarle la visibilidad de public para poder verlo, por default es solo visible dentro del contrato

Esteban Blanco Ortuno

student•

No se pero me parece que esta mal....

Omar Daniel Centeno

student•

Hola, Esteban,

¿Qué es lo que te parece que está mal?

Fernando Campos

student•

Hola 👋🏼 Antes que nada, qué increíble que estás tratando de resolver los retos por ti mismo. Aprendes muchísimo cuando pones en práctica lo que se ve en la clase y tratas de resolver los problemas. Ahora si observemos el código.

Lo primero que te pide el reto es crear un contrato para un proyecto de crownfunding y agregar variables de estado. Tú creaste el contrato, bien 👌🏼 Aunque te confundiste un poco con los corchetes {}. Dejaste la función ChangeProjectState fuera de los corchetes del contrato. Tampoco agregaste las variables de estado. La idea de tener estás variables es almacenar información sobre el proyecto, por ejemplo: el nombre, el creador, los fondos con los que cuenta y el total de fondos que quiere lograr. Aquí puedes ver cómo queda en código esta parte del constructor con las varibles de estado del proyecto.

constructor(
        string memory _id,
        string memory _name,
        string memory _description,
        uint256 _fundraisingGoal
    ) {
        id = _id;
        name = _name;
        description = _description;
        fundraisingGoal = _fundraisingGoal;
        author = payable(msg.sender);
    }

El segundo punto es hacer una función para añadir fondos al proyecto. Esto sí lo hiciste con tu función sendEther 👌🏼 Tu función recibe el parametro receiver, es decir, cada vez que llames a la función debes decirle a que dirección enviar los fondos. En la siguiente clase verás que el profesor usa la variable de estado author para establecer esta dirección en el constructor y la asigna a la dirección de quien crea el contrato. Él hace esto para que no necesites indicar manualmente la address, en una forma más sencilla. Aquí puedes ver cómo sería esta función.

function fundProject() public payable {
        author.transfer(msg.value);
        funds += msg.value;
    }

El punto tres es crear una función para cambiar el estado del proyecto. Lo que tú hiciste en tu función ChangeProjectState es regresar un string. Lo ideal es crear una variable de estado y en esta función solo recibir como parámetro el nuevo valor y asignarlo a nuestra variable.

function changeProjectState(string calldata newState) public {
        state = newState;
    }

Finalmente, debes unir estas tres partes dentro de un contrato y listo! En la siguiente clase verás la solución completa explicada por el profesor. 😁

Andyno Cortez

student•

Minuto 0:30, seria, este no se Deberia borrar nunca, Nunca es mucho tiempo.

Jose Leonardo Omaña Cortes

student•

Data location
- Dentro de Solidity las variables pueden tener un lugar distinto de almacenamiento, dependiendo para qué los utilicemos y donde los utilicemos
- Storage
  - Memoria Persistente
  - Variable guardada en el Storage de un contrato
    - Storage se guarda en la Blockchain
    - Siempre se va a mantener el valor almacenado pues este nunca se va a borrar
- Memoria
  - no persistente
  - Una variable almacenada en memoria es no persistente
  - Memory (Modificable) solo existe mientras se llama la función
  - Esta variable también se puede modificar mientras estemos dentro de la función
- CallData
  - También es no persistente
  - Se almacena solo mientras se está usando
  - No puede ser modificada mientras se usa
  - Esto hace que se reduzca el GAS necesario para ejecutar una función
Por defecto las variables de estado se almacenan en el storage
Los parámetros de una función se almacenan en memoria
Los únicos tipos de variables a los que se les puede definir un almacenamiento distinto son las variables de tipo String y las variables de tipo Array y Mapping

Marlos Rodriguez

student•

Este es mi resultado del reto, fue muy divertido lograr este resultado y finalmente verlo (aunque sea solo un juguete :D ), use un poco de ayuda de los aportes anteriores.

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;

contract PlatziCrowdFunding {
    //Initial variables
    string ProjectName;
    string ProjectDescription;
    address Owner;
    address payable ownerWallet;
    bool Isfondeable;
    uint256 Goal;
    uint256 RequiredFunds;
    uint256 totalFunded;

    constructor(string memory _projectName, string memory _projectDescription){
        Owner = msg.sender;
        ownerWallet = payable(msg.sender);

        ProjectName = _projectName;
        ProjectDescription = _projectDescription;

        Isfondeable = true;
        Goal = 0;
        totalFunded = 0;
    }

    modifier OnlyOwner {
        require(msg.sender == Owner, "You are not the owner of this project");
        _;
    }

    function setProjectGoal(uint256 _goal) public OnlyOwner {
        Goal = _goal;
    }

    function ChangeProjectState(bool change) public OnlyOwner {
        Isfondeable = change;
    }

    function ViewGoal() public view returns(uint256) {
        return Goal;
    }

    function ViewTotalFounds() public view returns(uint256) {
        return totalFunded;
    }

    function ViewRemaining() public view returns(uint256) {
        uint256 remaining = Goal - totalFunded;
        return remaining;
    }

    function FoundProject() public payable {
        require(msg.sender != Owner, "The Owner can't found its own project");

        //IF the project is still alive
        require(Isfondeable, "The project is not longer available");

        //If the goal is not reach yet
        require(totalFunded < Goal, "The Goal is already reach");

        //Check valid amount
        require(msg.value != uint(0), "Please add a amount to contribute to the project");

        //Check not exceed the goal
        require(totalFunded + msg.value <= Goal, "unable to add more funds, check amount remaining for our goal");

        ownerWallet.transfer(msg.value);
        totalFunded += msg.value;
    }
}

Javier Flores

student•

Hola, en mi caso asigné una address del "benficiario", pero me da error al no poder convertir el tipo. En todo caso, como se podria, por ejemplo, hacer un contrato donde se asigna una address como constante?

Andres Felipe Pardo Mesa

student•

Para crear una constante de tipo address escribela sin comillas, si quieres que sea de tipo payable tienes que hacer la conversión de address a payable usando la función payable()

address payable public author= payable(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4);

Dual.william.may

student•

Profe, ¿qué son las variables de estado?

Andres Felipe Pardo Mesa

student•

Són las variables que se definen en el smart contract, fuera de las funciones

Albert Bou Hernandez

student•

Hola! cual puede ser el error si al hacer deploy del contrato Remix devuelve:

creation of MyContract pending…

Y no llega a desplegarlo nunca

Andres Felipe Pardo Mesa

student•

Que te aparecer en environment ?

Dayana Lucia Verdugo Alejo

student•

Estuve probando el reto #1, pero no estoy segura si está bien o si era lo solicitado. Ayuda por favor

Dayana Lucia Verdugo Alejo

student•

Aquí está la corrección correspondiente. Me di cuenta que no había aclarado bien las variables.

Ary Tomás

student•

Hola, yo estudio estos cursos desde la pagina de REMIX, pero a veces uso una notebook y a veces una PC de escritorio... el tema es que cuando abro el REMIX en la notebook y en la PC son diferentes almacenamientos, no tengo los mismos archivos, alguien sabe como puedo sincronizar el REMIX en ambos dispositivos?

Andres Felipe Pardo Mesa

student•

Que interesante pregunta, para sincronizarlo la única forma que veo es usando github guardar el avance de tus archivos y luego cargando los archivos desde github en el otro dispositivo

Ary Tomás

student•

Gracias por tu respuesta anfepar!

Daniel Cardenas Parra

student•

Hola a todos soy muy nuevo en esto pero quiero hacerles mi aporte es como lo entendi y lo que aprendi lo hice muy sencillo, gracias: // SPDX-License-Identifier: GPL-3.0pragma solidity >=0.7.0 <0.9.0; contract Project { address public owner; // Guardará la dirección del dueño del contrato uint public fondos; // Guardará la cantidad de fondos bool public activo; // Indica si el proyecto está activo

// Constructor: se ejecuta una sola vez cuando se despliega el contrato constructor() { owner = msg.sender; // 'msg.sender' es quien despliega el contrato (el dueño) activo = true; // El proyecto comienza activo por defecto } // Funcion que permite enviar ether a un proyecto function fundProject() public payable { require(activo, "El proyecto no esta activo."); // Verifica si el proyecto está activo fondos+=msg.value; // msg.value es la cantidad de ether que se envía } // Funcion que nos va a permitir cambiar el estado del proyecto function changeProjectState() public{ require(msg.sender == owner, "Solo el dueno puede cambiar el estado."); activo = !activo; // Cambia el estado: si está activo lo desactiva, y viceversa }}```js // SPDX-License-Identifier: GPL-3.0 pragma solidity >=0.7.0 <0.9.0;

contract Project {

address public owner; // Guardará la dirección del dueño del contrato
uint public fondos;    // Guardará la cantidad de fondos
bool public activo;    // Indica si el proyecto está activo


// Constructor: se ejecuta una sola vez cuando se despliega el contrato
constructor() {
    owner = msg.sender;  // 'msg.sender' es quien despliega el contrato (el dueño)
    activo = true;     // El proyecto comienza activo por defecto
}

// Funcion que permite enviar ether a un proyecto
function fundProject() public payable {
    require(activo, "El proyecto no esta activo.");  // Verifica si el proyecto está activo
    fondos+=msg.value;  // `msg.value` es la cantidad de ether que se envía
}
// Funcion que nos va a permitir cambiar el estado del proyecto
function changeProjectState() public{
    require(msg.sender == owner, "Solo el dueno puede cambiar el estado.");
    activo = !activo;  // Cambia el estado: si está activo lo desactiva, y viceversa

}

}

Oscar Cuenca Roca

student•

Siguiendo mi ejemplo de sensor de temperatura, supongamos que el sensor forma parte de un proyecto agrícola de alta tecnología donde se quiere monitorear la temperatura de un campo en tiempo real. Este proyecto agrícola busca financiamiento, y la comunidad puede enviar fondos (ether) para apoyarlo.

fundProject:

Los interesados pueden financiar el proyecto enviando ether. Esto podría ser usado para mantener el sensor, para realizar investigaciones relacionadas con los datos recopilados, o para expandir el proyecto y agregar más sensores.

changeProjectStatus:

A medida que el proyecto avanza, el propietario puede cambiar el estado del proyecto para informar a la comunidad sobre su progreso.

Funciones de visibilidad:

public: Pueden ser llamadas desde fuera y dentro del contrato. Por ejemplo, geoposition es una variable pública, por lo que se genera automáticamente una función getter que permite a cualquier persona ver la geoposición.

external: Solo pueden ser llamadas desde fuera del contrato. Es más eficiente que public para funciones que siempre serán llamadas desde fuera. Ejemplo: updateTemperature.

internal: Solo pueden ser llamadas desde el mismo contrato o contratos derivados. Son útiles para funciones de utilidad que no deben ser expuestas. Ejemplo: internalFunction.

private: Solo pueden ser llamadas desde el mismo contrato. Son útiles para funciones y variables que no deben ser accesibles de ninguna otra manera. Ejemplo: privateFunction

Este contrato ahora no solo registra y actualiza la temperatura, sino que también permite el financiamiento del proyecto y la actualización del estado del mismo. En un contexto real, esto podría representar un sistema de crowdfunding para proyectos agrícolas que desean utilizar sensores IOT para mejorar sus operaciones.

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.8.7 <0.9.0;

contract TemperatureSensor {

// Datos del sensor

string public geoposition;

string public macAddress;

int public temperature;

address public owner;

address public wallet;

uint public funds;

enum ProjectStatus { NotStarted, InProgress, Completed }

ProjectStatus public status;

modifier onlyOwner() {

require(msg.sender == owner, "Only the owner can perform this action");

}

constructor(

string memory _geoposition,

string memory _macAddress,

int _initialTemperature,

address _wallet

) {

geoposition = _geoposition;

macAddress = _macAddress;

temperature = _initialTemperature;

owner = msg.sender;

wallet = _wallet;

funds = 0;

status = ProjectStatus.NotStarted;

}

function updateTemperature(int _newTemperature) external onlyOwner {

temperature = _newTemperature;

}

function fundProject() external payable {

funds += msg.value;

}

function changeProjectStatus(ProjectStatus _newStatus) external onlyOwner {

status = _newStatus;

}

// Función con visibilidad internal

function internalFunction() internal view returns(uint) {

return funds * 2;

}

// Función con visibilidad private

function privateFunction() private view returns(uint) {

return funds / 2;

}

// Estas funciones son solo para demostrar la visibilidad. No tienen un propósito real en este contrato.

}

Samir Jimenez Vivas

student•

Dentro de Solidity las variables se pueden almacenar en diferentes lugares.

Una variable en el Storage de la blockchain nunca se borrará, es memoria persistente. Una variable en la memoria se borra, solo sirve en funciones. Una variable almacenada en el calldata, es lo mismo que la variable en memoria, PERO el parametro NO se cambia, útil para usar variables que sepas que no se van a modificar. Recuerda que todo aquí usa GAS como en Attack on Titan.