conceptos basicos sobre contratos inteligentes
La elección de Solidity en Ethereum es solo una de las varias opciones disponibles. En general, se selecciona por su popularidad, pero la lógica detrás de Solidity y otros lenguajes y plataformas de BlockCjain es similar.
Así que nos centraremos en conceptos básicos que pueden ayudar a entender el contexto de los NFT y los contratos inteligentes en BlogChain.
En su momento, también tuve dudas similares, así que permitan que sea un poco flexible en la precisión de los términos, ya que el objetivo es proporcionar una idea general del contexto y no un manual exhaustivo sobre Solidity, NFT o Smart Contract.
De momento haremos algunos comentarios basicos de lo que son NFT y Smart Contract, pero en algunos casos Los NFT puedes ser configurados como Smart Contract, ya que estos últimos tienen mayores prestaciones e inteligencia de procesos.
Desde luego hay casos en que no estamos interesados en este tipo de prestaciones y el NFT se ajusta suficientemente bien en aquellos caso en que se desea usar la tecnología para la gestación de tokens que no se puedan cambiar en el timepo y que definan claramente la propiedad del mismo.
Naturaleza y función: Los NFT son tokens digitales únicos e indivisibles que representan la propiedad o autenticidad de un activo digital específico, como arte, música, coleccionables, etc. Por otro lado, los contratos inteligentes son programas informáticos que definen y ejecutan acuerdos digitales automáticamente, permitiendo la automatización de procesos y la eliminación de intermediarios.
Utilidad y aplicaciones: Los NFT se utilizan principalmente en el ámbito de los activos digitales únicos y coleccionables, donde se valora su singularidad y autenticidad. Los contratos inteligentes tienen una amplia gama de aplicaciones.
Complejidad y programación: La creación y gestión de NFT puede ser relativamente sencilla, y generalmente se basa en estándares predefinidos como el estándar ERC-721 o ERC-1155 en Ethereum. Por otro lado, los contratos inteligentes requieren una programación más compleja y personalizada utilizando lenguajes como Solidity.
Ver codigo de ejemplo al final del documento con la creaciíon de un NFT de una boleta de acceso a un evcento con valor, fecha y hora del mismo.
¿Por qué usar Solidity y BlogChain más allá de ser una tecnología de moda?
El uso de Solidity se ve principalmente como una capa de seguridad, pero no es su único beneficio. Algunas ventajas adicionales son la transparencia, la automatización de procesos, la eliminación de intermediarios, la inmutabilidad, el acceso global y la eficiencia.
La transparencia se refiere a que los NFT y los contratos inteligentes se ejecutan en la blockchain, lo que significa que todas las transacciones y acciones realizadas en el contrato son visibles y verificables por cualquier persona.
La inmutabilidad se refiere a que una vez que un contrato inteligente se despliega en Ethereum, sus reglas y lógica son inmutables, lo que implica que no pueden ser modificados por ninguna de las partes. Esto proporciona garantía de que nadie podrá cambiar el contrato.
¿Qué significa la automatización en el contexto de los contratos inteligentes?
La automatización es uno de los puntos a destacar en esta tecnología, ya que una vez que se lanza el contrato, se ejecuta sin intervención humana. Por ejemplo, si queremos pagar 3 cuotas mensuales después de lanzar el contrato, podemos establecer las reglas para que el contrato verifique las fechas de pago y realice los pagos automáticamente si hay saldo suficiente. Esto elimina la necesidad de que alguien recuerde realizar los pagos manualmente. Solidity en Ethereum se encarga de procesar y realizar los pagos según las reglas establecidas.
¿Puedo utilizar inteligencia artificial dentro de Solidity?
Sí, es posible, pero no se recomienda debido a los costos y tiempos involucrados. Es más práctico y recomendable utilizar procesos externos e integrarlos con Solidity a través de interfaces como web3.js, que permite cargar y leer información desde y hacia Solidity.
¿Solidity tiene una base de datos transaccional como PostgreSQL o una base de datos NoSQL como MongoDB para almacenar información?
No, Solidity utiliza la blockchain de Ethereum para almacenar de forma segura toda la información en bloques.
¿Puedo crear un modelo CRUD (Creación, Lectura, Actualización y Borrado) en Solidity?
Sí, es posible crear un modelo CRUD en Solidity, pero con algunas limitaciones. Por ejemplo, las operaciones de borrado y actualización no se realizan de la misma manera que en las bases de datos tradicionales. En lugar de modificar los registros existentes, se crea un nuevo bloque de datos con la nueva información. En el caso del borrado, el dato ya no está disponible para su uso, aunque no desaparece por completo. Ver código de ejemplo al final del documento. con una boleta de acceso a un evento con identificador unico, nombre y cantidad que se va aguardar en blogchain
¿Puedo realizar consultas como en las bases de datos tradicionales en Solidity o en la blockchain?
Sí y no. Si bien es posible realizar consultas en Solidity, estas son costosas en términos de recursos y están limitadas. Las consultas en la blockchain aún están en una etapa inicial, similar a las consultas básicas en SQL en los primeros días. Una práctica común es utilizar una técnica híbrida, donde la información necesaria se almacena tanto en la blockchain como en una base de datos transaccional o NoSQL, lo que permite su manipulación y posterior procesamiento en Solidity bajo un esquema de alta seguridad.
¿Tiene algún costo el uso de la cadena de bloques de Solidity en Ethereum?
Sí, algunas operaciones tienen costo. En general, todas las operaciones de escritura, como crear, actualizar o borrar datos, tienen un costo. Las operaciones de lectura son generalmente gratuitas o tienen un costo muy bajo. Los costos de transacción, denominados GAS, dependen de diversos factores, como la cantidad de líneas de ejecución, la congestión de la red en el momento de la operación y los costos comerciales de Ether, que es la moneda utilizada en Ethereum y está sujeta a oferta y demanda. Por eso, es recomendable optimizar el código de Solidity y limitar su uso solo a los procesos necesarios para que el contrato cumpla con su función específica. Para cálculos complejos, es mejor realizarlos de forma externa o mediante oráculos propios o de terceras partes.
¿Qué son los oráculos en Solidity y los contratos inteligentes?
Los oráculos son fuentes externas de información que permiten que los contratos inteligentes obtengan datos sin tener que realizar los cálculos ellos mismos. Los oráculos pueden proporcionar información como fechas, valores de bolsa, condiciones climáticas, resultados deportivos, entre otros. También es posible crear oráculos personalizados donde se consulte información externa y se pase al contrato inteligente. Esto ayuda a optimizar los recursos en tiempo y dinero.
En general, es una buena práctica delegar tareas complejas, cálculos intensivos y verificaciones externas a los oráculos, y utilizar Solidity principalmente para la automatización, seguridad y lógica de negocio del contrato inteligente.
¿En qué etapa de desarrollo se utiliza un contrato inteligente o un modelo de blockchain efectuado en Solidity?
Si se utiliza el esquema de desarrollo MVC (Modelo-Vista-Controlador), Solidity actúa como el modelo y controlador, es decir, maneja la lógica del negocio y el almacenamiento de datos. En general, Solidity y la blockchain proporcionan el backend de la aplicación.
¿Cómo se desarrolla el frontend para que funcione con Solidity y la blockchain?
Es posible seleccionar herramientas como HTML, CSS y lenguajes como JavaScript, jQuery o Angular, entre otros, que tengan interfaces de integración. En el caso de JavaScript y sus derivados, existe la biblioteca web3.js, que permite la interacción e integración gratuita con Solidity.
¿Cuáles son las ventajas de una DApp en comparación con una aplicación convencional?
Las DApps (aplicaciones descentralizadas) proporcionan características similares a las que ofrecen Solidity y la blockchain, como transparencia, eliminación de intermediarios, seguridad de datos y gobernanza descentralizada.
Sin embargo, es importante tener en cuenta que las DApps no necesariamente brindan una mejor experiencia de usuario o un diseño más atractivo en comparación con las aplicaciones convencionales. El aporte de Solidity y la blockchain se centra en el backend y la seguridad de los datos, mientras que la interfaz de usuario es independiente de su uso.
Para enfatizar mas este concepto, es posible utilizar todo el sistema de seguridad y des centralización y demás ventajas que ofrecen los Bigchain como se explico anteriormente en una aplicación sin cambiar nada en las interfaces de usuario y utilizando Solidity en el backend con instrucciones java, o sea manteniendo la vista exactamente igual y reforzando o mejorando los procesos de modelo y controlador en el backend usando contenedores como Tomcat o cualquiero ortro conrtnedor basado en java del tipo , Glassfish, Payara o WildFly.
En estos casos se usa webj.class de lado del servidor en lugar de web3.js que se utiliza con javascript de lado del usuario.
Para usuarios de python existen librerías como web3.py, Eth-ABI y Brownie entre otras.
He encontrado deferentes versiones que permiten trabajar para diferentes lenguajes como c++, en cada caso hay que verificar si se adaptan a lo que se pretende o en su lugar usarla la web3.js de lado del cliente que en teoría es mas sencilla, pero mi recomendación es todos los casos es explorar la forma de hacerlo desde el lado del servidor por temas de separación de capas MVC y seguridad.
En algunos casos he usado las librearas de Python por su robustez y facilidad y las integro mediante otro proceso a mi lenguaje de interés en el servidor , usando incluso algunos scripts sencillos en Llnux y/o EC2 en el sistema operativo para facilitar el proceso. Esto me ha sido particularmente útil para administrar respuestas de procesos automáticos por ejemplo para el envió de correos y SMS cuando un evento se producto como respuesta a un contrato inteligente por ejemplo para notificar que un pago no pudo ser efectuado.
En resumen Solidity en Etherum y blogchain prestan servicios de seguridad y descentralizador de la información, el desarrollo de la interfaces de usuario no le compete de ninguna forma ya que lo que proporciona es el backend y reglas del negocio. El uso mesurado de los contratos y su conformación es vial para optimizar los costos y tiempos de ejecución de una red descentralizada con las demoras propias de este tipo de redes.
Ejemplo de CRUD en Solidity
* Observar que una buena veriricar si la operaciíon se puede realizar mediante require en aquellas que se desea accesar uun registor que se supo existe
Crea un registro con un identificador del registro, cantidad y nombre que se desea almacenar en blockchain
pragma solidity ^0.8.0;
contract CRUDContract {
struct Item {
uint256 id;
string name;
uint256 quantity;
}
Item[] public items;
uint256 public itemCount;
function createItem(string memory _name, uint256 _quantity) public {
Item memory newItem = Item(itemCount, _name, _quantity);
items.push(newItem);
itemCount++;
}
function getItem(uint256 _id) public view returns (uint256, string memory, uint256) {
require(_id < itemCount, "Item does not exist");
Item storage item = items[_id];
return (item.id, item.name, item.quantity);
}
function updateItem(uint256 _id, string memory _name, uint256 _quantity) public {
require(_id < itemCount, "Item does not exist");
Item storage item = items[_id];
item.name = _name;
item.quantity = _quantity;
}
function deleteItem(uint256 _id) public {
require(_id < itemCount, "Item does not exist");
delete items[_id];
}
}
--------------------------------------------------------------------------------------------------------------------
Ejemplo de un NFT en Solidity que da acceso a un evento con valor, fecha y hora del evento.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract EventTicketNFT is ERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
struct EventTicket {
uint256 eventId;
string date;
string time;
uint256 value;
}
mapping(uint256 => EventTicket) private _eventTickets;
constructor() ERC721("EventTicketNFT", "ETNFT") {}
function createTicket(
address to,
uint256 eventId,
string memory date,
string memory time,
uint256 value
)
using Counters for Counters.Counter;
Counters.Counter private _tokenIdCounter;
struct EventTicket {
uint256 eventId;
string date;
string time;
uint256 value;
}
mapping(uint256 => EventTicket) private _eventTickets;
constructor() ERC721("EventTicketNFT", "ETNFT") {}
function createTicket(
address to,
uint256 eventId,
string memory date,
string memory time,
uint256 value
)
external returns (uint256) {
_tokenIdCounter.increment();
uint256 newTicketId = _tokenIdCounter.current();
_eventTickets[newTicketId] = EventTicket(eventId, date, time, value);
_safeMint(to, newTicketId);
return newTicketId;
}
function getTicketDetails(uint256 tokenId) external view returns (EventTicket memory) {
require(_exists(tokenId), "Ticket does not exist");
return _eventTickets[tokenId];
}
}
_tokenIdCounter.increment();
uint256 newTicketId = _tokenIdCounter.current();
_eventTickets[newTicketId] = EventTicket(eventId, date, time, value);
_safeMint(to, newTicketId);
return newTicketId;
}
function getTicketDetails(uint256 tokenId) external view returns (EventTicket memory) {
require(_exists(tokenId), "Ticket does not exist");
return _eventTickets[tokenId];
}
}
Comentarios
Publicar un comentario