Andres Omar Carreon Diaz
Pablo Palacios
Alexis Lozano Terán
Daniel Buitrago
Jean Nuñez
Juan Christopher
Pepe Sosa
Cristhian Vera Nieto
Juan Christopher
Cristopher Adasme
Javier Arley Sanchez Ledesma
Andres Felipe Pardo Mesa
Mario Eduardo Contreras Serrano
Javier Flores
Andres Felipe Pardo Mesa
Bramucci Candela
Andres Felipe Pardo Mesa
Esteban Blanco Ortuno
Omar Daniel Centeno
Fernando Campos
Andyno Cortez
Jose Leonardo Omaña Cortes
Marlos Rodriguez
Javier Flores
Andres Felipe Pardo Mesa
Dual.william.may
Andres Felipe Pardo Mesa
Albert Bou Hernandez
Andres Felipe Pardo Mesa
Dayana Lucia Verdugo Alejo
Dayana Lucia Verdugo Alejo
Ary Tomás
Andres Felipe Pardo Mesa
Ary Tomás
Daniel Cardenas Parra
Oscar Cuenca Roca
Samir Jimenez Vivas
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; } }
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
Quizas el mensaje de error que retorna onlyOwner lo cambiaria ya que no solamente se usa para setGoal, si no tambien para changeProjectState.
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.
gracias amigo buen aporte
Buen aporte.
Les dejo una cheatsheet que encontré, trae datos útiles.
exelente
Gracias, maquina.
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; } }
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; } } }```
El funcionamiento que debería tener este smart contract debería ser:
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/
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.
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
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; } }
Te falta agregarle la visibilidad de public para poder verlo, por default es solo visible dentro del contrato
No se pero me parece que esta mal....
Hola, Esteban,
¿Qué es lo que te parece que está mal?
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.
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); }
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; }
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. 😁
Minuto 0:30, seria, este no se Deberia borrar nunca, Nunca es mucho tiempo.
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; } }
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?
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);
Profe, ¿qué son las variables de estado?
Són las variables que se definen en el smart contract, fuera de las funciones
Hola! cual puede ser el error si al hacer deploy del contrato Remix devuelve:
creation of MyContract pending…
Y no llega a desplegarlo nunca
Que te aparecer en environment ?
Estuve probando el reto #1, pero no estoy segura si está bien o si era lo solicitado. Ayuda por favor
Aquí está la corrección correspondiente. Me di cuenta que no había aclarado bien las variables.
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?
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
Gracias por tu respuesta anfepar!
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 }
}
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.
}
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.