DEV Community: RGT

JWT con Node y Express

RGT — Mon, 16 Oct 2023 02:41:57 +0000

Hola a todos

Hola a todos hoy les traigo un minitutorial para poder utilizar JWT en Express y Node

Instalación

Instalamos con npm ejecutando el comando
npm install jsonwebtoken

También utilizaremos un par de librerías más como crypto y dotenv

npm install crypto dotenv express

crypto

Este módulo permite a los desarrolladores trabajar con operaciones criptográficas, como el cifrado y descifrado de datos, la generación de claves, la creación de resúmenes criptográficos (hashes) y más.

Este modulo lo utilizaremos para crear una clave para JWT para ello utilizaremos un metodo llamado randomBytes() el cual genera una secuencia de bytes aleatorios de longitud 64 utilizando una fuente de números aleatorios seguros proporcionada por la biblioteca criptográfica de Node.js. Los bytes generados son aleatorios y se consideran seguros para su uso en aplicaciones que requieren datos aleatorios, como claves criptográficas, tokens de autenticación, números de sesión y más.

dotenv

La dependencia dotenv es una herramienta comúnmente utilizada en aplicaciones Node.js para cargar variables de entorno desde un archivo llamado .env en el entorno de desarrollo. Estas variables de entorno suelen contener información sensible o configuración específica de la aplicación, como credenciales de bases de datos, claves de API, configuraciones de puerto, entre otros.

Una vez explicado lo que necesitamos y para que sirve pues Manos a la obra

En nuestro proyecto de node creamos un archivo para poder generar esta contraseña que servira como clave para generar nuestro jwt.

Nota: Este archivo es temporal solo nos servirá para poder generar nuestra contrasena, posteriormente si asi lo desean pueden eliminarlo

Archivo: encriptar.js

const crypto = require('crypto');
const Password = crypto.randomBytes(64).toString('hex');
console.log(Password);

lo guardamos con el nombre encriptar.js y lo ejecutamos con node de la siguiente manera:

node encriptar.js

El cual nos retornara la contraseña

Ahora teniendo la contrasena la guardamos en un archivo .env el cual debe quedar de la siguiente manera:

Archivo: .env

Hasta ahora vamos bien, comenzaremos por crear nuestro archivo index.js

Importaremos todas las dependencias que hemos instalado

Archivo: index.js

// importamos express
const express = require('express');
const app = express();
const router = express.Router();
// importamos jwt
const jwt = require('jsonwebtoken');

// importamos dotenv
const dotenv = require("dotenv");
// ejecutamos .config() el cual nos va a permitir acceder al archivo .env
dotenv.config();


// configurarmos el puerto donde correra nuestro servidor
//
app.set('port', process.env.PORT || 9090);

Ruta encriptar

Creamos una ruta llamada encriptar utilizando el método GET que recibe como parametro un nombre

Recibiremos mediante el parametro :nombre el valor a encriptar

app.get('/encriptar/:nombre', async (req, res)=>{
    try{

    // Recibimos como parametro el nombre
    const nombre = req.params.nombre;

    // Accedemos a la variable TOKEN_SECRET que guardamos en .env
    const SecretToken = process.env.TOKEN_SECRET;


    // Creamos el token proporcionandole lo que vamos  a encriptar, La llave, y el tiempo de expiración
    const token = jwt.sign({nombre:req.params.nombre}, SecretToken, {expiresIn:'1000s'});


    // Retornamos el token;
    res.status(200).send({msg:`El nombre es ${nombre}`, token:`${token}`})



    }
    catch(e){
    console.log("Ocurrio un error ", e);
    }

})

Posteriormente ponemos a la escucha el servidor el cual configuramos el puerto 9090

// ponemos a la escuchar el servidor creado
app.listen(app.get('port'), () =>{
    console.log(`Server on port ${app.get('port')}`);
})

Middleware

Los middlewares se utilizan comúnmente en aplicaciones web para procesar y manipular las solicitudes del cliente antes de que lleguen a la capa de la aplicación principal, lo que permite realizar tareas como la validación de datos, la seguridad y la gestión de sesiones

Crearemos un middleware para validar el token creando la funcion authenticateToken el cual recibe miente el header Authorization el token.

NOTA para enviar el token se realiza mediante el header Authorizacion y el parametro Beared + token

//  MIDDLEWARE 

function authenticateToken(req, res, next) {

  // Recibe el token mediante el header authorization
  const authHeader = req.headers['authorization']

  // obtiene el token 
  const token = authHeader && authHeader.split(' ')[1]

  // Se valida que el token sea enviado en caso contrario manda un error
  if (token == null) return res.status(401).send({msg : 'No ha ingresado un token'})

  jwt.verify(token, process.env.TOKEN_SECRET, (err, user) => {

    // VERIFICAMOS QUE EL TOKEN COINCIDA CON LA CONTRASENA
    if (err) return  res.status(403).send({msg : 'Token invalido'})
    req.token = user
    next()
  })
}

Utilizando el middleware authenticateToken

Creamos una nueva ruta llamada desencriptar donde agregamos el middleware que creamos. El cual nos retornara el token ya desencriptado y lo podemos utilizar mediante el parametro req.token.

Descencriptando

Mediante el método post creamos la ruta desencriptar pasandole el middleware el cual retorna el valor descencriptado

Nota: El usuario debera enviar el token a descencriptar mediante el HEADER

app.post('/desencriptar', authenticateToken,  async (req, res)=>{
    try{

    let Nobre = req.token.nombre;
    // Retornamos el token;
    res.status(200).send({msg:`El nombre es Nobre`})
    }
    catch(e){
    console.log("Ocurrio un error ", e);
    }

})

Bueno, ya teniendo esto ya tenemos listo todo nuestro código

para correr nuestro servidor ejecutamos

node index.js

Encriptando

Una vez corriendo el servidor utilizare POSTMAN para hacer pruebas.

Utilizamos el método get y como parámetro le envió un nombre en este caso rodrigo

Esto retorna el valor a encriptar y el token que se genera.

Desencriptando

Para poder descencriptar necesitamos enviar el token que obtuvimos mediante el metodo get y lo enviamos en los headers con el metodo Authorization y el parametro Beared

Esto retorna el token descencriptado.

Y eso es todo.

Iniciar sesion en mongodb con usuario y contraseña | Mongodb

RGT — Thu, 12 Oct 2023 20:59:20 +0000

Hola a todos

Hoy les traigo un nuevo minitutorial de como crear usuario y contrasena en mongodb

primero que nada entramos a la base de datos que deseamos colocarle la contreana para ello ejecutamos el comando

mongo

mongosh

una vez dentro de mongo seleccionamos el nombre de la base de datos donde queremos crear el usuario

para ello ejecutamos el comando


use NOMBRE_DE_LA_BASE_DE_DATOS

Una vez dentro ejecutamos el siguiente comando:

db.createUser(
{
user: "AQUI VA EL NOMBRE DEL USUARIO",
pwd: "AQUI VA LA CONTRASEÑA",
roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
}
)

Ahora solo resta activar la opcion para que permita usar la contrasena para ello nos vamos a la configuracion de mongo

En el caso de mac debería de estar en

/usr/local/etc/mongod.conf

en el caso de Ubuntu

/etc/mongodb.conf

agregamos las siguientes lineas:

security:
  authorization:enabled

Posteriormente reiniciarmos el servicio de mongodb-community

en el caso de mac

brew services restart mongodb-community

sudo systemctl restart mongod

ahora para poder conectarnos ejecutamos el siguiente comando

mongodb://NOMBRE_DEL_USUARIO:CONTRASENA@localhost:27017/NOMBRE_DE_LA_BASE_DE_DATOS

ESO ES TODO

LOS QUIERO

SALE BYE

Poner contrasena a PDF | qpdf

RGT — Sat, 07 Oct 2023 21:07:49 +0000

Hola a todos

El dia de hoy le enseñare como pueden poner contrasena a sus archivos de pdf de una manera muy sencilla.

Para ello necesitaremos instalar qpdf

¿Que es QPDF?

qpdf es una herramienta de código abierto utilizada para trabajar con archivos PDF (Portable Document Format). Proporciona una serie de funcionalidades para manipular y modificar archivos PDF, incluyendo la capacidad de dividir, fusionar, cifrar, descifrar, comprimir y reparar archivos PDF. También puede utilizarse para convertir documentos en otros formatos a PDF y viceversa.

Algunas de las tareas comunes que se pueden realizar con qpdf incluyen:

Dividir un archivo PDF en varios archivos más pequeños.
Fusionar varios archivos PDF en uno solo.
Cifrar un archivo PDF con una contraseña para proteger su contenido.
Descifrar un archivo PDF protegido por contraseña.
Comprimir imágenes dentro de un archivo PDF para reducir su tamaño.
Reparar archivos PDF dañados o corruptos.
Convertir documentos en otros formatos (como archivos de texto o imágenes) a PDF.
Realizar manipulaciones avanzadas en la estructura interna de un archivo PDF.
qpdf es una herramienta de línea de comandos y se utiliza principalmente en entornos de desarrollo y administración de sistemas. Es especialmente útil cuando se necesita automatizar tareas relacionadas con archivos PDF o realizar manipulaciones específicas en estos archivos.

Instalación

sudo apt install qpdf

Fin.

jajajaj

Encriptar

Para poder utilizar qpdf para poner una contrasena se realiza de la siguiente manera.

qpdf --encrypt "TUCONTRASENA" "TUCONTRASENA" 256 -- "NOMBRE_DE_TU_ARCHIVO_PDF" "NOMBRE_DE_TU_ARCHIVO_PDF_ENCRIPTADO";

Basicamente es todo lo que necesitas para encriptar. Como pueden ver es demasiado facil utilizar esta herramienta y bastante intuitiva

A continuación les muestro un ejemplo de como utilizar qpdf para encriptar todos los archivos de una carpeta utilizando bash.

#/bin/bash

# Directorio que contiene los archivos PDF a encriptar
directorio_pdf="./"
# Contraseña para encriptar los archivos PDF
contrasena="AQUIVATUCONTRASENA"

# Titulo
echo "Encriptador de PDFS"

# Itera sobre todos los archivos PDF en el directorio
for archivo_pdf in "$directorio_pdf"/*.pdf; do
    if [ -f "$archivo_pdf" ]; then

    # NOMBRE DEL ARCHIVO A ENCRIPTAR
    nombre_archivo=$(basename "$archivo_pdf")

    # NOMBRE DEL ARCHIVO ENCRIPTADO
    archivo_temporal="${nombre_archivo}_encriptado.pdf"

    echo "----------------"
    echo "Encriptando el archivo: $archivo_pdf"


    if qpdf --encrypt "$contrasena" "$contrasena" 256 -- "$archivo_pdf" "$directorio_pdf/${archivo_temporal}"; then
        echo "El comando se ejecuto correctamente"

        rm "$directorio_pdf/${nombre_archivo}"
        cp "$directorio_pdf/${archivo_temporal}" "$directorio_pdf/${nombre_archivo}"
        rm "$directorio_pdf/${archivo_temporal}"

    else
        echo "Ocurrio un error al ejecutar el comando"
    fi
    #echo "Encriptado: $archivo_pdf -> ${nombre_archivo}_encriptado.pdf"
    fi
done

echo "Proceso completado."

SQL | Cifrar datos

RGT — Sun, 24 Sep 2023 14:29:32 +0000

Hola a todos

Hoy les quiero compartir un código hecho en php para poder cifrar los datos de su base de datos y poder descencriptarlos esto con la finalidad de mejorar la seguridad de sus BD.

Quiero aclarar que este codigo lo obtuve de el video de lastDragon solo lo mejore un poco

Link del video de last dragon

<?php
class Encriptar
{
    private $llave;
    private $vector;

    public function __construct($llave = 'AQUI VA TU LLAVE', $vector = 'AQUI VA TU VECTOR TIENE QUE TENER SOLO 16 CARACTERES')
    {
        $this->llave = $llave;
        $this->vector = $vector;
    }

    public function cifrar($texto)
    {
        // Convertir el texto a base64 para manejar comillas simples y caracteres especiales
        $textoCodificado = base64_encode($texto);
        $cifrado = openssl_encrypt($textoCodificado, 'aes-256-cbc', $this->llave, OPENSSL_RAW_DATA, $this->vector);
        if ($cifrado === false) {
            throw new Exception('Error al cifrar los datos.');
        }
        return base64_encode($cifrado);
    }

    public function descifrar($cifrado)
    {
        $descifrado = openssl_decrypt(base64_decode($cifrado), 'aes-256-cbc', $this->llave, OPENSSL_RAW_DATA, $this->vector);
        if ($descifrado === false) {
            throw new Exception('Error al descifrar los datos.');
        }
        // Decodificar desde base64 para obtener el texto original
        return base64_decode($descifrado);
    }
}

Ejemplo de uso

<?php
    include_once "encriptar.php";

    $Encriptar= new Encriptar();
    $encriptado =  $Encriptar->cifrar("Texto a encriptar");

    echo "Texto cifrado es: " . $encriptado;

    // DESCENCRIPTANDO ...
    echo "Texto descifrado es: " .$Encriptar->descifrar($encriptado);

¿Que es OPENSSL_ENCRYPT?

openssl_encrypt es una función en PHP que se utiliza para cifrar datos utilizando la biblioteca OpenSSL. OpenSSL es una biblioteca de código abierto que proporciona implementaciones de varios protocolos de seguridad, incluyendo SSL (Secure Sockets Layer) y TLS (Transport Layer Security), así como algoritmos de cifrado y funciones criptográficas.

La función openssl_encrypt se utiliza para cifrar datos utilizando diferentes algoritmos de cifrado simétrico, como AES (Advanced Encryption Standard), DES (Data Encryption Standard), y otros. Permite cifrar datos utilizando una clave secreta y, opcionalmente, un vector de inicialización (IV) para mejorar la seguridad.

Aquí tienes un ejemplo simple de cómo se utiliza openssl_encrypt en PHP:

$data = "Hola, mundo!";
$clave = "MiClaveSecreta";
$iv = random_bytes(16); // Vector de inicialización aleatorio

$cifrado = openssl_encrypt($data, 'AES-256-CBC', $clave, 0, $iv);

echo "Texto cifrado: " . $cifrado;

En este ejemplo, estamos cifrando el mensaje "Hola, mundo!" utilizando el algoritmo AES-256 en modo CBC (Cipher Block Chaining) con una clave secreta y un IV generados aleatoriamente.

Es importante destacar que el uso seguro de openssl_encrypt implica la gestión adecuada de las claves y otros parámetros de seguridad, así como el almacenamiento seguro de dichas claves. El cifrado es una parte fundamental de la seguridad de datos, y su implementación incorrecta puede llevar a vulnerabilidades de seguridad.

Conectar con ssh de mac a ubuntu

RGT — Sun, 10 Sep 2023 18:13:00 +0000

Hola a todos

Hoy traigo un nuevo tutorial, en este caso es para conectar por ssh una computadora mac a una con ubuntu. Pero se puede hacer para cualquier S.O.

Bueno, pues, a darle.

Configurar SSH en la computadora Ubuntu:

Asegúrate de que el servicio SSH esté instalado y en ejecución en tu computadora Ubuntu. Puedes hacerlo ejecutando los siguientes comandos en la terminal de Ubuntu:

sudo apt update
sudo apt install openssh-server
sudo systemctl start ssh

Esto instalará el servidor SSH y lo pondrá en funcionamiento en tu computadora Ubuntu.

Obtener la dirección IP de la computadora Ubuntu:

Necesitarás conocer la dirección IP de tu computadora Ubuntu en la red local. Puedes obtenerla ejecutando el siguiente comando en la terminal de Ubuntu:

ip a | grep inet

Busca una línea que comience con "inet" y tenga una dirección IP que se parezca a 192.168.x.x o 10.x.x.x. Esta es la dirección IP de tu computadora Ubuntu en la red local.

ufw

Firewall o reglas de seguridad:

Es posible que un firewall o reglas de seguridad estén bloqueando las conexiones SSH. Asegúrate de que el puerto 22 (el puerto predeterminado para SSH) esté abierto en el firewall de tu servidor. Puedes utilizar el siguiente comando para ver las reglas de firewall activas:

sudo ufw status

Si ves que el puerto 22 está en la lista de reglas denegadas, debes agregar una regla para permitirlo:

sudo ufw allow 22/tcp

Luego, reinicia el firewall:

sudo ufw reload

Eso es todo lo que debemos de configurar en la computadora ubuntu

MAC

Para la computadora mac solo tenemos que conectarnos con ssh

ssh NOMBREUSUARIO@IP_DEL_SERVIDOR

Ejemplo:

ssh root@192.168.1.2

Te pedira la contrasena que es la misma del usuario de ubuntu

Deployar en una subcarpeta React con React-Router-Dom en servidor Nginx con Vite

RGT — Fri, 18 Aug 2023 21:12:26 +0000

Hola a todos

En esta ocasión les traigo un nuevo tutorial para poder deployar su aplicación en una subcarpeta

NGINX

Dentro de Nginx debemos de configurar nuestro servidor de la siguiente manera

        location /[AQUÍ VA EL NOMBRE DE LA SUBCARPETA]{
            try_files $uri $uri/ /[SUBCARPETA]/index.html?$args;
        }

Dentro del location tendremos que poner el nombre de la subcarpeta para cuando accedan ahí cargue los archivos necesarios accediendo a Nombre de la subcarpeta/index.html y que cargue el archivo html.

Con esto garantizamos que se carguen los archivos que queremos al momento de acceder a una ruta de la subcarpeta

vite.config.js

Si no existe el archivo de configuración lo creamos

import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'

// https://vitejs.dev/config/
export default defineConfig({
  base: 'https://[RUTA DEL SERVIDOR]/[Nombre de la subcarpeta]/',
  plugins: [react()],
})

Nota: La ruta del servidor es ejemplo: rodrigo.hgo.mx

main.jsx

En el main.jsx de nuestra aplicacion debemos de definir el publicPath para todas nuestras rutas

const publicPath = '/[NOMBRE DE TU SUBCARPETA]/';

const router = createBrowserRouter([
  {
    path: publicPath,
    element: <Root/>,
    errorElement: <ErrorPage />, 
  },
  {
    path: `${publicPath}encuesta`,
    element: <Contact />,
  },

]);



// AQUI EN EL ROUTER PROVIDER DEBEMOS DE PONER EL BASENAME 

ReactDOM.createRoot(document.getElementById('root')).render(
  <React.StrictMode>
    <RouterProvider router={router} basename="/[NOMBRE DE TU SUBCARPETA]">
    </RouterProvider>
  </React.StrictMode>,
)

Como subir un proyecto de laravel con nginx

RGT — Tue, 15 Aug 2023 18:15:27 +0000

Hola a todos

En este post quiero compartirles como le hice para subir mi proyecto hecho en Laravel con un servidor nginx

Nginx

Primero modifique mi configuración de mi servidor nginx de la siguiente manera

    server {
        client_max_body_size 604M;
        listen 80;
        server_name localhost;
        proxy_read_timeout 3000;
        proxy_connect_timeout 3000;
        proxy_send_timeout 3000;

    #index index.php index.html index.htm;
   index index.php index.html index.htm;


        location / {
            root html;
        try_files $uri $uri/ /PruebaLaravel/public/index.php?$is_args$args;

        }

        location ~ \.php$ {
            root html;
            fastcgi_pass 127.0.0.1:9000;
            fastcgi_index index.php;
            fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
            include fastcgi_params;

        }


    }

Como notaran en la sección location
tengo el siguiente código

try_files $uri $uri/ /PruebaLaravel/public/index.php?$is_args$args;

Este código sirve para que cuando entren a PruebaLaravel public les cargue las rutas correctamente.

Laravel

Para la sección de laravel lo unico que hice fue subir mi proyecto y configurar el archivo .env que por defecto al momento de subirlo (con git) el archivo cuenta con un .gitignore el cual elimina vendor y el archivo .env

Pór lo que primero debemos de ejecutar el comando

composer install

Posteriormente debemos de editar el archivo .env.example lo único que hice fue con el comando cp ejecutar lo siguiente

cp .env.example .env

Luego de ejecutar ese comando que lo que hace es crear el archivo .env con la configuración del .env.example

posteriormente debemos de crear el apikey, para esto debemos de ejecutar el comando

php artisan key:generate

Que lo que hace básicamente es generarnos una clave en base64 y colocarla en el archivo .env automaticamente.

debe quedar nuestro archivo .env de la siguiente manera

APP_KEY=base64:nwS6IQobORgUqweqweqw1UVPMox8YBmuaffm/3ZvCOdasdasd

nginx

Les recomiendo proteger su configuracion de .env con nginx de la siguiente manera

    location = /PruebaLaravel/.env{
        autoindex off;
        deny all;
        return 404;
    }

P.D. No olviden asignar los permisos necesarios para acceder a la carpeta.

Curso | Solidity | modifier

RGT — Mon, 07 Aug 2023 15:23:03 +0000

Hola a todos

Hoy les traigo un minitutorial del curso de solidity que estoy tomando, al finalidad de esto es que aprendamos juntos ya que no soy experto en solidity si no que estoy apenas aprendiendo y la idea es explicar lo que he entendido con el objetivo de aprender-enseñando

modifier

El término "modifier" se refiere a una característica que te permite definir una serie de comprobaciones o condiciones que deben cumplirse antes de que una función pueda ser ejecutada. Los modificadores son una forma de modularizar y reutilizar lógica en tus contratos inteligentes, lo que hace que el código sea más claro y fácil de mantener.

Los modificadores son particularmente útiles para aplicar lógica de verificación o validación antes de permitir que una función realice su tarea. Pueden utilizarse para verificar que ciertas condiciones se cumplan antes de que una función cambie el estado del contrato o realice alguna acción importante. Al utilizar modificadores, puedes evitar la duplicación de código y garantizar que ciertas validaciones se apliquen consistentemente en diferentes partes de tu contrato.

Aquí hay un ejemplo simple para ilustrar cómo se utiliza un modifier en Solidity:

pragma solidity ^0.8.0;

contract Ejemplo {
    address public owner;

    constructor() {
        owner = msg.sender;
    }

    modifier soloOwner() {
        require(msg.sender == owner, "¡Solo el propietario puede ejecutar esta función!");
        _;  // Esta línea indica dónde se ejecutará el cuerpo de la función una vez que se valide el modifier.
    }

    function hacerAlgo() public soloOwner {
        // El código de la función se ejecutará solo si el modifier "soloOwner" valida.
        // Hacer algo interesante aquí...
    }
}

En este ejemplo, el modifier soloOwner verifica si la dirección que llama a la función es la misma que la dirección del propietario del contrato. Si no lo es, la función no se ejecutará y arrojará una excepción. Si la comprobación del modifier pasa, la función hacerAlgo se ejecutará normalmente.

En resumen, los modificadores en Solidity son una herramienta poderosa para agregar condiciones de validación y lógica reutilizable a tus funciones de contrato inteligente, lo que ayuda a mejorar la seguridad y la claridad del código.

Curso | Solidity| require

RGT — Thu, 03 Aug 2023 15:47:30 +0000

Hola a todos

// SPDX-License-Identifier: MIT
pragma solidity 0.8.18;

contract Variables{

function PruebaRequire(uint valor) public pure returns(bool)
{
    require(valor==5, "EL VALOR NO ES IGUAL A 5");
    return true;
}

}

Este contrato contiene una función llamada "PruebaRequire" que toma un valor como parámetro y verifica si ese valor es igual a 5 utilizando la función require. Si la condición se cumple, la función devuelve true. Si el valor no es igual a 5, la función se detiene y muestra un mensaje de error.

Al momento de deployar el contrato podremos observar que al enviar un 5 en el valor este no retorna ningún error;

Y podremos ver más información dando clic donde dice CALL para ver que retorna un valor bool que dice true.

Pero en caso de enviar un numero diferente se notificara de esta manera.

Eso es todo por el dia de hoy

Curso| Solidity | funciones

RGT — Mon, 31 Jul 2023 04:13:17 +0000

Hola

Continuando con el curso hoy toca funciones

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

contract Funciones{

    function suma(uint a, uint b) external pure returns(uint){

        return a + b;

    }

    function resta(uint a, uint b) external  pure returns(uint)
    {
        return a - b;

    }
}

SPDX-License-Identifier: MIT: Esta es una directiva especial llamada "SPDX-License-Identifier" que se utiliza para especificar la licencia bajo la cual se distribuye el contrato inteligente. En este caso, el contrato está bajo la licencia MIT, que es una licencia de software libre muy común y permite que otros puedan utilizar, modificar y redistribuir el código con ciertas condiciones.

pragma solidity 0.8.13: Esta es otra directiva que especifica la versión del compilador de Solidity que se debe utilizar para compilar el contrato. En este caso, se está utilizando la versión 0.8.13 de Solidity.

contract Funciones: Aquí se define el contrato inteligente llamado "Funciones".

function suma(uint a, uint b) external pure returns(uint): Esta es una función llamada "suma", que toma dos parámetros de tipo uint (números enteros sin signo) y devuelve un resultado uint. La palabra clave "pure" indica que esta función no modifica el estado del contrato ni lee datos del mismo; es decir, es una función que solo realiza cálculos internos y no interactúa con el blockchain de Ethereum.

function resta(uint a, uint b) external pure returns(uint): Esta es otra función llamada "resta", que también toma dos parámetros de tipo uint y devuelve un resultado uint. Al igual que la función "suma", es una función "pure" que solo realiza cálculos internos.

Ambas funciones son declaradas como "external", lo que significa que pueden ser llamadas desde fuera del contrato (por ejemplo, desde otros contratos o desde una transacción externa a través de una interfaz de usuario).

En resumen, este contrato inteligente proporciona dos funciones, "suma" y "resta", que realizan operaciones matemáticas simples y no modifican el estado del contrat

Para poder ejecutar la funcion tenemos que pasarle los datos en este caso se pasan los parametros separados por una coma.

Clase 2| SOLIDITY | Creación de variables

RGT — Mon, 31 Jul 2023 02:36:51 +0000

Hola a todos

Continuando con el curso de solidity vamos a ver los tipos de variables

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;


contract Variables {

    string public miNombre = "Rodrigo";
    int256 public entero = 12313123;
    int8 public otro_entero = 2;
    address public direccion = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;

}

En resumen, este contrato define cuatro variables públicas:

miNombre: Es una variable de tipo string (cadena de caracteres) y tiene asignado el valor "Rodrigo". Esta variable es pública, lo que significa que cualquier persona o contrato que interactúe con este contrato puede leer su valor.

entero: Es una variable de tipo int256 (entero de 256 bits) y tiene asignado el valor 12313123. Al igual que la anterior, esta variable es pública y su valor puede ser leído por cualquiera.

otro_entero: Es una variable de tipo int8 (entero de 8 bits) y tiene asignado el valor 2. También es pública y su valor es accesible por cualquier persona o contrato.

direccion: Es una variable de tipo address (dirección de Ethereum) y tiene asignado el valor 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4. Al ser pública, la dirección almacenada puede ser consultada por cualquiera.

Las variables tipo direccion sirve para tener la dirección de una cartera.

Clase 1|SOLIDITY| Hola mundo

RGT — Mon, 31 Jul 2023 00:17:22 +0000

Hola a todos

Voy a comenzar a estudiar solidity nuevamente y por lo tanto voy a utilizar dev.to para guardarlo como un blog para recordar mi codigo

Primero debemos de conectarnos a Remix

SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

contract HolaMundo {
string public miNombre = "Rodrigo";
}

SPDX-License-Identifier: MIT

Este comentario es un identificador de licencia que se utiliza para especificar qué tipo de licencia se aplica al código fuente. En este caso, indica que el código está licenciado bajo la Licencia MIT. La Licencia MIT es una licencia de código abierto muy permisiva que permite a cualquiera usar, modificar, distribuir y compartir el código bajo ciertas condiciones. El uso de este identificador facilita la comprensión de la licencia del código por parte de otras personas que quieran utilizarlo.

pragma solidity 0.8.13;

Esta declaración pragma indica la versión del compilador de Solidity que se debe utilizar para compilar el contrato. En este caso, se está utilizando la versión 0.8.13 de Solidity.

Este contrato se llama "HolaMundo" y contiene una sola variable llamada miNombre, que es de tipo string. La variable está declarada como pública, lo que significa que es accesible desde fuera del contrato.

La línea string public miNombre = "Rodrigo"; inicializa la variable miNombre con el valor "Rodrigo". Al ser pública, se genera automáticamente una función de lectura (getter) que permite a otros usuarios leer el valor de miNombre desde fuera del contrato.

En resumen, este contrato es bastante simple y su única funcionalidad es almacenar y permitir la lectura del nombre "Rodrigo" en la variable miNombre. Es común encontrar ejemplos de "Hola Mundo" cuando se presentan lenguajes de programación o contratos para mostrar la estructura básica y la sintaxis. Sin embargo, en aplicaciones descentralizadas más complejas, los contratos pueden tener funcionalidades mucho más avanzadas y útiles.

Despues de tener nuestro código listo debemos de compilarlo

Para poder compilarlo debemos dar clic en las opciones que se encuentran en el lado izquierdo

Despues de estar compilado debemos deployarlo

Despues de deployarlo podremos ver la variable que creamos dando clic en minombre

Y automaticamente nos debe de mostrar el nombre de nuestra variable