Esta serie está basada en dos recursos principales: El curso de Atrium Academy sobre Uniswap v4 y la documentación oficial del protocolo. Mi objetivo aquí no es (por ahora) enseñar algo original, sino aportar recursos en español, explicados de la manera más sencilla posible, a la vez que aprendo y construyo en púbico para que más builders latinos puedan sumarse a DeFi.

Finalmente, las imágenes utilizadas también fueron tomadas de Atrium Academy y la documentación oficial a menos que indique lo contrario. Ahora sí, empecemos a aprender Uniswap 🚀🦄!

Cómo empezó todo

La historia de Uniswap es bastante interesante, aquí va en unas cuantas líneas: Hayden Adams, fundador de Uniswap se había perdido su primer trabajo después de salir de la universidad. Desempleado, su ex-compañero de escuela Karl Floersch (quien ahora es CEO de OP Labs) lo anima a meterse en el mundo de web3 y Ethereum. Hayden practicamente no sabía programar, pero poco a poco empezó a ir a conferencias y entender DeFi a fondo. En algún momento, el paper con la idea original de un DEX desarrollada por Martin Koppelman y luego expandida por Vitalik, cae en sus manos y se pone manos a la obra, gracias a una beca de la Ethereum Foundation.

Uniswap v1 se lanza en noviembre de 2018. Dato curioso 🤓☝️, se iba a llamar UniPeg pero Vitalik les aconsejó pivotear a Uniswap 😆. En algún punto después del lanzamiento, Hayden se da cuenta que para escalar esta idea, necesitará gente muy talentosa, así que en Abril de 2019 levantan capital, en una ronda liderada por Paradigm y así comienza el crecimiento exponencial del DEX más grande de web3.

Ahora que ya conocemos los comienzos de Uniswap, hagamos un repaso rápido de las principales innovaciones técnicas de cada una de las versiones del protocolo

Uniswap v1

Uniswap v1 es bastante sencillo de entender. Estos son los puntos principales:

• Consistía de un solo Factory Contract, cualquiera podía desplegar una pool

• Solo podían hacerse swaps de ETH a un token ERC-20.

• Es la primera implementación de un Automated Market Maker (AMM), más especificamente un Constant Product Market Maker (CPMM), lo que da paso a la famosa fórmula para explicar Uniswap: xy = k (no te preocupes, explicaremos todo esto con detalle más adelante)

• El problema principal de v1 es que no podías swappear de ERC-20 a ERC-20 (esto implicaba una UX mala, y costos de gas innecesarios)

Uniswap v1 explicado en un diagrama: Si querías hacer algo tan simple como swappear DAI por USDC, tenías qué swappear DAI por ETH, y luego ETH por USDC, esto significaba clicks y firmas por todos lados y costos de gas altos (recuerda, era 2018 y todo se hacía sobre Ethereum mainnet)

Uniswap v2

A mediados de 2020 se lanzó Uniswap v2 con algunas innovaciones técnicas geniales pero que sobre todo representó el hito más grande de DeFi, 🎯 hasta el momento y hasta donde sé, es el protocolo más forkeado de la historia.

Uniswap v2 introdujo 3 innovaciones super importantes:

1. Ya se puede hacer swaps de ERC-20 a ERC-20 usando un contrato router 🥳

2. Se introduce el TWAP Oracle 👁️, no muy usado en estos tiempos, pero una gran innovación en su momento

3. Se introducen los Flash Swapas (como Flash Loans, pero para swaps)

Ya sé, seguramente te quedaste pensando, qué diablos es TWAP Oracle? Culpa mía, pues bueno TWAP significa Time-Weighted Average Price Oracle y basicamente es un oráculo on-chain (un contrato) que calcula el precio medio de un activo promediando su valor a lo largo de un intervalo de tiempo. Así, si alguien trataba de manipular el precio subitamente haciendo un trade muuuy largo, el TWAP Oracle sacaba un promedio y no se podían hacer cosas raras con esos oráculos! 👮🏻

Diagramas de Atrium para explicarlo mejor 🤓:

Ahora, nuevas soluciones generalmente traen nuevos problemas, en Uniswap v2 estos eran:

• Los proveedores de liquidez sufrían mucha impermanent loss debido a la manera en que funciona la curva xy = k

• Provoca ineficiencias de precio ya que muchos tokens realmente no van a ser tradeados en los extremos de la curva

Pero de ¿qué curva me hablas? Veamos 🤓

Uniswap v3

Uniswap v3 fue lanzado en 2021 trayendo consigo una gran innovación 👨‍🔬: Liquidez concentrada 🌊. Ahora, los LPs pueden decidir en qué rango de la curva quieren proveer su liquidez. Esto tiene una parte mala y una parte buena: La mala es que si el precio del activo sale del rango de liquidez donde estás proveyendo dejas de ganar fees. La buena es que el capital ahora es más eficiente que nunca.

En la siguiente imagen solo es necesario aprender una cosa:

En la v2 (izquierda) la curva de precio no toca los ejes, es continua, se expande infinitamente ya que recuerda (por nuestra querida fórmula xy = k ), entre más escaso es un activo más caro es, hasta que su precio tienda al infinito pero nunca se acaba.

En v3 (derecha) es todo lo contrario. La curva tiene un punto muy específico donde empieza y donde termina (es discreta). Esto quiere decir, un LP provee liquidez en un cierto rango, o….🥁🥁🥁 Liquidez Concentrada 🌊!

Pero otra vez, nuevas soluciones traen nuevos problemas, como estos 🥸:

• Demasiados forks resultaban en una mala experiencia para tod@s, ya que la liquidez quedaba fragmentada y brincando de protocolo en protocolo

• Muchos forks no eran auditados por lo que hubo muchos hackeos y rugpulls

• Los usuarios finales quedaban también confundidos sin saber que DEX les convenía usar

Así que después de un arduo proceso de debate y construcción comunitaria y en público…llega Uniswap v4 al rescate 🦄!

Uniswap v4

Uniswap v4 fue lanzado en enero de 2025, después de un largo camino de recopilación de ideas y construcción en público. Su feature más sonado, son sin duda los hooks 🪝, que nos permiten crear funcionalidades nuevas sobre Uniswap sin necesidad de crear un fork nuevo del DEX!

Pero no solo eso, v4 trae muchas más innovaciones 🤓:

• Nuevo sistema de contabilidad para liquidar saldos entre maker y taker

• Se utiliza por primera vez Transient Storage (EIP-1153) para optimización de gas

• Flash Accounting, permite liquidar saldos pendientes al final de la transancción

• Usuarios pueden no retirar sus tokens de las pools para ahorrar fees

Todas estas nuevas herramientas en v4 dan lugar a un espacio de diseño muy muy grande, se pueden construir muchísimas cosas 👷!

Algunas ideas que da Uniswap:

• Libros de órdenes onchain

• Curvas de precios personalizadas para crear mercados más eficientes para ciertos tokens (por ejemplo, stablecoins)

• Menos MEV tóxico

• Comisiones dinámicas que reaccionan ante situaciones del mundo real

• Depositar de liquidez fuera de rango en protocolos de lending, para que los LPs ganen rendimiento incluso cuando no se generan fees por swaps

• Auto-compounding de comisiones para reinvertir automáticamente en la posición de LP

• Creación de DEXes empresariales con pools que cumplen con KYC

Si te emociona construir estas ideas o las tuyas propias con hooks, quédate en los siguientes artículos para que aprendamos la arquitectura técnica de v4, algo más de teoría y matemáticas DeFi y empecemos a crear nuestros propios hooks, LFB el DeFi latinoamericano 🚀🫡!

• Morpho is a lending protocol that puts the emphasis in permissionless and effective lending: minimum governance constraints, anyone can deploy their own isolated lending market, and with additional layers like Morpho Vaults, capital is rotated to where it is most needed and accrues more yield.

Let’s keep learning from the Morpho docs and dive deeper into the next 2 topics: Liquidation and the Oracle-Agnostic model.

Liquidation

First, we have two concepts that we need to understand:

• Loan-To-Value (LTV)

• Liquidation Loan-To-Value (LLTV)

Loan-To-Value

LTV is a metric used in tradfi to determine the risk involved in a loan. Here in DeFi, it represents the value of the loaned amount relative to the value of the collateral. For example, if a user deposits $10,000 worth of ETH as collateral and the lending platform allows an LTV of 50%, they can borrow up to $5,000 in stablecoins or another asset.

To calculate the LTV of a position in Morpho, we use a simple formula:

LTV = (BORROWED_AMOUNT ORACLE_PRICE) / (COLLATERAL_AMOUNT) (ORACLE_PRICE_SCALE)

where ORACLE_PRICE_SCALE = 1e36.

Liquidation Loan-To-Value

If LTV is a metric to determine how much the amount to borrow is worth, relative to the collateral, LLTV is a metric that determines how much an entity can borrow before being liquidated. In other words, LLTV is a risk parameter that defines at what LTV ratio (Loan-To-Value) a loan becomes undercollateralized and subject to liquidation. The formula is very simple: LLTV = LOAN_AMOUNT / COLLATERAL_VALUE.

Example: Let’s say a market in Morpho sets an 85% LLTV liquidation threshold. Alice deposits $1,000 worth of ETH and borrows $800 worth of USDC. Her initial LLTV is 80% which is relatively safe, but if the price of ETH falls and her LTV reaches 85%, liquidation occurs.

How Liquidations work in Morpho

Liquidations are simple: a liquidator can liquidate up to 100% of the amount owed and received the corresponding collateral value, plus the relative incentive.

No fee is taken by the Morpho protocol at this level. The entire Liquidation Incentive Factor (LIF) goes to the liquidator. I will not try to disect the formula to calculate the LIF at this point, but if you’re curious you can check the Morpho docs.

To continue with their example, if a borrower provided $1000 of collateral in a market that has a LLTV of 80%, and their debt reaches just above $800, the position is liquidatable.

In this case the formula would be: SEIZABLE_ASSETS = DEBT_AMOUNT LIF = 800 1.06 = 848.

The liquidator would seize up to $848 of collateral and the borrower would keep $152 of the collateral they provided initially.

TLDR for LIF: The lower the LLTV, the higher the LIF. The more difficult it is to get liquidated, the higher percentage the liquidator can take.

Oracle-Agnostic Pricing

Finally, let’s look at how Morpho approaches oracles. First, a lending protocol obviously needs to know the price of the assets lended and collateralized. Oracles are the primary method for querying such prices.

Determining a price without using oracles requires a lending protocol to have internal trading markets, which makes the whole system less gas efficient, more complex and prone to new attack vectors.

Morpho uses an oracle-agnostic rather than oracle-less approach. The protocol has no oracle or trading mechanism built into it. When you create a market you are responsible for providing an address for a working oracle be it from Chainlink, Pyth, Uniswap or whichever.

Morpho mentions markets may also have prices hardcoded or use a mechanism like the one Ajna uses, we will explore that later.

Conclusion

With that, we’ve covered two very important pieces of the Morpho architecture: Liquidations and Oracles. In the following articles we will keep exploring more of their architecture to become through lending experts. Let’s keep building 🚀.

What is Morpho?

Morpho follows this paradigm of having a ‘Labs’ as a regular entity that built the original tech, a DAO and a protocol. Morpho Labs was co-founded by Paul Frambot, Merlin Egalite, Julien Thomas, and Mathis Gontier Delauney. Frambot, the CEO, secured a $1 million seed round during his final year as an engineering student, followed by a $20 million investment from Andreessen Horowitz and Variant. The protocol launched on Ethereum mainnet in July 2022.

From their docs, Morpho showcases 6 main products or topics:

• Morpho

• Morpho Vaults

• Bundlers

• Public Allocator

• Rewards

• Morpho Optimizers (deprecated)

Let’s take a look at the main product: the Morpho protocol. Morpho is a decentralized lending and borrowing protocol designed to be more efficient and flexible than traditional DeFi lending platforms. In Morpho you can deploy a minimal and isolated lending market by specifying:

• One collateral asset

• One loan asset

• A Liquidation Loan-To-Value (LLTV)

• An Interest Rate Model (IRM)

• An oracle

We will see what all these means through the series.

Unlike traditional lending protocols that require governance approval for asset listings and parameter changes, Morpho allows for permissionless market creation. Anyone can create a market with different collateral tokens, borrowable tokens, and oracles, and for the LLTV and IRM you have to choose between the options pre-approved by the Morpho DAO governance.

The following LLTVs have been DAO-approved: [0%; 38.5%; 62.5%; 77.0%; 86.0%; 91.5%; 94.5%; 96.5%; 98%].

The only Interest Rate Model (IRM) that has been DAO-approved is the AdaptiveCurveIRM, which we will cover in another article.

In Morpho, markets are named in the following format:

CollateralAsset/LoanAsset (LLTV, ORACLE, IRM)

so a market named wstETH/WETH (94.5%, ChainlinkOracle, AdaptiveCurveIRM) is very simple to read: the collateral asset is wstETH, the asset to loan is WETH, the LLTV is 94.5%, the oracle to be used is from Chainlink and the interest rate model that will be used is AdaptiveCurveIRM. Simple.

Key Features of Morpho

• Overcollateralized lending: Borrowers must provide more collateral than the value of their borrowed assets.

• Immutable protocol: Once deployed, Morpho will function in perpetuity without governance interference, provided the blockchain where it is deployed keeps functioning.

• Permissionless market creation: Each market has fixed parameters, ensuring stability and predictability.

• Externalized risk management: Users, rather than protocol governance, determine risk exposure.

• Oracle-agnostic pricing: Rather than being oracle-less, Morpho allows market creators to choose their preferred price oracle.

Governance and Risk Management

Traditional platforms centralize risk management through governance voting. For example, AAVE token holders vote on whether an asset like SHIB can be used as collateral and determine its risk parameters. This approach limits scalability and forces users into a single risk model.

Morpho decentralizes risk management, allowing users to create and interact with any deployed market. This enables:

• Customizable risk profiles

• Greater asset diversity

• Scalable and autonomous lending markets

For example, Morpho Labs created Morpho Vaults, which is a product built on top of Morpho which facilitates the creation of lending vaults on top of Morpho markets. This is how they work in a nutshell:

• A "Vault" is a smart contract that aggregates funds from multiple lenders.

• A "Curator" manages the vault’s risk parameters and strategy.

• The Vault then supplies funds across different Morpho markets in an optimized way.

This allows passive lenders to supply their assets and forget about assessing which markets have the appropriate collateral, LLTV, oracle, and IRM, the vault does it on their behalf.

In the following articles we will keep dissecting key Morpho concepts like understanding how their liquidation mechanism works, how they interest rate model works and, much more.

Conclusion

Morpho is a very interesting DeFi lego which introduces a new paradigm in decentralized lending by enabling immutable, permissionless markets with user-controlled risk management. Unlike traditional lending platforms like AAVE and Compound, Morpho removes governance bottlenecks and empowers users with greater flexibility. Many more products can be built on top of this like their Morpho Vaults, flash loans and more. We will cover more of these topics in upcoming articles. Keep building 🚀

A few days ago, Argentine President Javier Milei had a fiasco promoting (or rather, broadcasting) a crypto scam on his personal account. Two days ago, we witnessed the biggest hack in crypto history—Lazarus Group tricked the ByBit team and made off with $1.4 billion in ETH and other tokens. People are arguing and fighting all day over culprits, solutions, an Ethereum rollback, criticizing Vitalik as a leader, the Ethereum Foundation, and Ethereum as a project. Others are disappointed because Solana and pump.fun wiped out their savings. Meanwhile, "leaders" and "builders" are busy creating the pump.fun of X blockchain, the pump.fun of derivatives, NFTs, undercollateralized loans... It all seems like absolute chaos.

And when you’re trying to finally break into the industry—not just as a user or a spectator from the sidelines—even more questions and complexities arise. What course should I take? Which ecosystem, which vertical, which language? Vyper, Solidity, or Cairo? Which chain should I focus on? Base launched a bootcamp, Scroll, Abstract, Mantle... The sheer overload feels like waking up after a brutal hangover, questioning your life decisions. Extending the party, going full-time crypto. But here we are, markets keep bleeding, week is still young and may bring along some more disappointing news but it feels like its not time to go home yet.

There’s so much left to learn and so many things to explore still. If you’re curious, if you have a legitimate passion to build cool stuff and solve real problems, and have a high risk-high reward mentality, its not time for us to go home yet.

¿Qué Son los Nested Mappings?

Un nested mapping es simplemente un mapping cuyo valor es otro mapping. Esto te permite almacenar datos en estructuras jerárquicas, como una matriz de datos indexados por múltiples claves.

Ejemplo Básico

Aquí un ejemplo de cómo declarar y usar un nested mapping en Solidity:

contract NestedMappings01 {

    mapping(uint256 => mapping(uint256 => uint256)) public nestedMap;

    function setNestedMap(
        uint256 key1,
        uint256 key2,
        uint256 finalValue
    ) public {
        nestedMap[key1][key2] = finalValue;
    }

    function getNestedMap(
        uint256 key1,
        uint256 key2
    ) public view returns (uint256) {
        return nestedMap[key1][key2];
    }
}

En este ejemplo:

• nestedMap asocia una clave key1 a otro mapping, que a su vez asocia key2 con un valor final.

• setNestedMap permite establecer un valor en el mapping anidado.

• getNestedMap recupera el valor almacenado en las claves key1 y key2.

Visualización de Nested Mappings

Supongamos que llamamos a setNestedMap(1, 2, 100). El resultado se vería así en pseudocódigo:

{
  1: {
    2: 100
  }
}

Aquí, 1 es la clave del primer mapping, que apunta a un segundo mapping. En ese segundo mapping, 2 es la clave que apunta al valor 100.

Restricciones y Peculiaridades de los Nested Mappings

1. Los Nested Mappings Públicos No Funcionan Como Esperas

Si declaras un mapping como public, Solidity genera automáticamente una función getter para acceder a sus valores. Sin embargo, en el caso de nested mappings, el getter requiere que proporciones todas las claves necesarias para recuperar un valor.

Por ejemplo, con el nested mapping nestedMap, el getter generado automáticamente permite llamar a nestedMap(1, 2) para obtener el valor asociado. No puedes acceder al mapping interno completo.

Solución: Usa Funciones Envolventes

Para mayor control, puedes declarar el mapping como private y crear funciones públicas que manejen el acceso:

contract NestedMappings02 {
    mapping(uint256 => mapping(uint256 => uint256)) private nestedMap;

    function setNestedMap(uint256 key1, uint256 key2, uint256 finalValue) public {
        nestedMap[key1][key2] = finalValue;
    }

    function getNestedMap(uint256 key1, uint256 key2) public view returns (uint256) {
        return nestedMap[key1][key2];
    }
}

2. No Puedes Iterar Sobre Nested Mappings

Al igual que con los mappings simples, Solidity no permite iterar sobre los keys de un nested mapping. Esto se debe a que todas las claves posibles son válidas y retornan su valor predeterminado si no han sido definidas.

Casos de Uso de Nested Mappings

Los nested mappings son muy útiles para modelar relaciones complejas. Algunos ejemplos comunes incluyen:

1. Sistemas de Permisos: Un mapping puede asociar direcciones de usuarios con permisos específicos.

    mapping(address => mapping(string => bool)) private permissions;
   

2. Balances Detallados: Puedes almacenar balances separados por categorías para cada usuario.

    mapping(address => mapping(string => uint256)) private balances;
   

3. Datos Jerárquicos: Estructuras como tablas relacionales se pueden modelar fácilmente con nested mappings.

Conclusión

Los nested mappings son una herramienta versátil en Solidity para manejar datos complejos. Aunque tienen limitaciones, como la imposibilidad de iterar sobre las claves o acceder a mappings internos completos a través de getters automáticos, estas restricciones se pueden manejar con buenas prácticas de diseño.

Si estás modelando relaciones jerárquicas o estructuras multi-clave, los nested mappings pueden ser tu mejor aliado. ¡Prueba los ejemplos en Remix para experimentar con estas ideas! 🚀

Introducción a los Mappings

Un mapping en Solidity asocia una clave de un tipo específico con un valor de otro tipo específico. Aquí un ejemplo básico:

contract Mappings01 {
    mapping(uint256 => uint256) public myMapping;

    function setMapping(uint256 key, uint256 value) public {
        myMapping[key] = value;
    }

    function getValue(uint256 key) public view returns (uint256) {
        return myMapping[key];
    }
}

En este contrato:

• setMapping almacena un valor asociado con una clave.

• getValue recupera el valor asociado con una clave.

Valor Predeterminado

Si accedes a un mapping con una clave que no ha sido definida, no obtendrás un error. En su lugar, el mapping retornará el valor predeterminado del tipo de datos del valor:

• Para uint256: 0.

• Para bool: false.

• Para address: 0x0000000000000000000000000000000000000000.

Ejemplo:

contract Mappings02 {
    mapping(uint256 => bool) public mapToBool;
    mapping(uint256 => uint256) public mapToUint;
    mapping(uint256 => address) public mapToAddress;

    function getDefaultValues(uint256 key) public view returns (bool, uint256, address) {
        return (mapToBool[key], mapToUint[key], mapToAddress[key]);
    }
}

Casos de Uso Comunes

Uso en Tokens ERC-20

Los tokens ERC-20 utilizan mappings para almacenar balances de usuarios. Por ejemplo:

contract ERC20Token {
    mapping(address => uint256) public balances;

    function setBalance(address owner, uint256 amount) public {
        balances[owner] = amount;
    }

    function transfer(address sender, address receiver, uint256 amount) public {
        balances[sender] -= amount;
        balances[receiver] += amount;
    }
}

En este caso:

• balances mapea una dirección a un saldo.

• La función transfer() permite ajustar los saldos de los usuarios.

Nota: Esta implementación carece de restricciones de seguridad; cualquiera puede transferir tokens. Esto es solo un ejemplo simplificado.

Restricciones de los Mappings

1. Solo Pueden Declararse en Storage

Los mappings deben ser declarados como variables de estado (en storage). No puedes declararlos dentro de funciones o como parámetros:

contract BrokenContract {
    function wontWork() public view {
        mapping(uint256 => uint256) someMap; // Esto no compilará
    }
}

2. No Pueden Ser Iterados

No hay manera de iterar sobre las claves de un mapping porque técnicamente todas las claves posibles son válidas y simplemente retornan el valor predeterminado si no han sido definidas.

Esto significa que si necesitas iterar sobre datos, deberías usar un array en combinación con el mapping.

3. No Pueden Ser Retornados

Los mappings no son un tipo de datos válido para ser retornado por funciones públicas o externas:

contract BrokenContract {
    mapping(uint256 => uint256) public someMap;

    function wontWork() public view returns (mapping(uint256 => uint256)) {
        return someMap; // Esto no compilará
    }
}

Buenas Prácticas con Mappings

1. Combínalos con Arrays: Si necesitas iterar sobre datos, guarda las claves en un array separado.

2. Define Acceso Público Cuidadosamente: Aunque puedes declarar un mapping como public, ten cuidado al permitir acceso público para evitar exponer datos sensibles.

3. Usa Valores Predeterminados con Precaución: Asegúrate de manejar correctamente los valores predeterminados para evitar errores lógicos.

Ejemplo Completo: Pop and Swap con Mappings y Arrays

contract ExampleWithMappingAndArray {
    mapping(address => uint256) public balances;
    address[] public users;

    function addUser(address user, uint256 balance) public {
        balances[user] = balance;
        users.push(user);
    }

    function removeUser(address user) public {
        uint256 index = findUserIndex(user);
        balances[user] = 0;
        users[index] = users[users.length - 1];
        users.pop();
    }

    function findUserIndex(address user) internal view returns (uint256) {
        for (uint256 i = 0; i < users.length; i++) {
            if (users[i] == user) {
                return i;
            }
        }
        revert("User not found");
    }
}

Este contrato:

• Usa un array para almacenar las claves del mapping.

• Permite iterar indirectamente sobre los usuarios.

Conclusión

Los mappings son herramientas poderosas para almacenar y acceder a datos en Solidity, especialmente cuando no necesitas iterar sobre ellos. Aunque tienen restricciones, su simplicidad y eficiencia los hacen esenciales para muchos casos de uso, incluidos los tokens ERC-20.

¡Prueba estos ejemplos en Remix para familiarizarte con sus conceptos y limitaciones! 🚀

¡Vamos a explorar cómo funciona todo esto! 🚀

Operaciones Básicas en Arrays de Storage

Aquí tienes un ejemplo básico de cómo trabajar con arrays almacenados en storage:

contract ArraysInStorage01 {
    uint256[] public myArray;

    function setMyArray(uint256[] calldata newArray) public {
        myArray = newArray; // Asigna el contenido de newArray a myArray
    }

    function addToArray(uint256 newItem) public {
        myArray.push(newItem); // Agrega un elemento al final
    }

    function removeFromArray() public {
        myArray.pop(); // Elimina el último elemento
    }

    function getLength() public view returns (uint256) {
        return myArray.length; // Devuelve la longitud del array
    }

    function getEntireArray() public view returns (uint256[] memory) {
        return myArray; // Devuelve el array completo
    }
}

Interacción en Remix

1. setMyArray: Establece un nuevo array, por ejemplo, [1, 2, 3].

2. addToArray: Agrega un nuevo número al final, como 4. El array se convierte en [1, 2, 3, 4].

3. removeFromArray: Elimina el último elemento. El array ahora es [1, 2, 3].

4. getLength: Devuelve 3, la longitud del array.

5. getEntireArray: Retorna [1, 2, 3].

Acceso Público a Arrays

Cuando un array es declarado como public, Solidity genera automáticamente una función getter que permite acceder a sus valores. Sin embargo, este getter solo devuelve elementos individuales, no el array completo.

Por ejemplo, al llamar myArray(0) obtendrás el primer elemento, pero si necesitas todo el array, debes usar una función como getEntireArray.

¿Qué pasa con pop()?

La función pop() elimina el último elemento del array y reduce su longitud, pero no retorna el valor eliminado como es común en otros lenguajes de programación.

Eliminando Elementos del Array

Solidity no permite eliminar un elemento en el medio de un array y ajustar automáticamente su longitud. Si intentas hacerlo, el valor será reemplazado por cero, pero la longitud del array no cambiará.

contract ExampleContract {
    uint256[] public myArray;

    function removeAt(uint256 index) public {
        delete myArray[index]; // El elemento se convierte en 0
    }
}

Pop and Swap: Una Solución Común

Si necesitas eliminar un elemento y reducir la longitud del array, puedes usar el patrón pop and swap. Este método reemplaza el elemento a eliminar con el último elemento y luego utiliza pop() para reducir la longitud:

contract ExampleContract {
    uint256[] public myArray;

    function popAndSwap(uint256 index) public {
        uint256 valueAtTheEnd = myArray[myArray.length - 1];
        myArray[index] = valueAtTheEnd; // Reemplaza con el último elemento
        myArray.pop(); // Reduce la longitud
    }
}

Este enfoque no preserva el orden original del array, pero es eficiente en términos de gas.

Conclusión

Trabajar con arrays en storage te brinda una gran flexibilidad para manejar datos en la blockchain. Desde agregar y eliminar elementos hasta manipular arrays completos, estas herramientas son esenciales para desarrollar smart contracts robustos.

Sin embargo, es importante tener en cuenta las limitaciones, como la falta de soporte para eliminar elementos en medio del array mientras se preserva su orden.

¡Experimenta con estos conceptos en Remix y observa cómo puedes usarlos en tus próximos proyectos de Solidity! 🚀

¿Qué Son las Variables de Estado?

En Solidity, las variables de estado son aquellas que se declaran fuera de las funciones y quedan guardadas en la blockchain después de que una transacción finaliza. Ejemplo:

contract StateVariables01 {
    uint256 internal x; // Variable de estado x

    function setX(uint256 newValue) public {
        x = newValue;
    }

    function getX() public view returns (uint256) {
        return x;
    }
}

En este ejemplo:

• x es una variable de estado que almacena un valor entero.

• setX() modifica el valor de x. Nota que como ésta función cambia el estado de la blockchain, no tiene el modificador view o pure.

• getX() lee el valor de x. Tiene el modificador view porque lee la blockchain pero no la modifica.

Visibilidad: ¿Quién Puede Acceder a Estas Variables?

Cuando declaras una variable de estado, puedes definir su visibilidad con palabras clave como public, internal o private.

Opciones de Visibilidad

• public:

  • Cualquier contrato o cuenta externa puede leer la variable.

  • El compilador genera automáticamente una función getter.

• internal:

  • Accesible solo dentro del contrato y en contratos que lo heredan.

• private:

  • Similar a internal, pero no accesible desde contratos derivados.

Por ejemplo, al cambiar la visibilidad de una variable a internal o private, notarás que los botones para interactuar con esa variable desaparecen en Remix.

contract HelloWorld {
    string private text;

    constructor() {
        text = "Hello World";
    }

    function helloWorld() internal view returns (string memory) {
        return text;
    }
}

Diferencia entre internal y private

La visibilidad internal permite que contratos heredados accedan a la variable o función, mientras que private restringe el acceso únicamente al contrato original.

Modificadores de Mutabilidad: pure, view, y más

Los modificadores como pure y view definen si una función puede leer o modificar el estado de la blockchain.

Tipos de Mutabilidad

• pure: No lee ni modifica el estado. Estas funciones son las más eficientes en términos de gas.

    function addNumbers(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }
  

• view: Puede leer el estado, pero no modificarlo. Llamar estas funciones directamente es gratuito.

    function getX() public view returns (uint256) {
        return x;
    }
  

• payable: Permite que la función reciba Ether.

    function deposit() public payable {
        // código para manejar depósitos
    }
  

• Sin modificador o non-payable (default): Puede leer y modificar el estado de la blockchain.

    function setX(uint256 newValue) public {
        x = newValue;
    }
  

Ejemplo Práctico: Variables de Estado y Modificadores

Aquí tienes un contrato que combina variables de estado con diferentes visibilidades y modificadores de mutabilidad:

contract ExampleContract {
    uint256 public balance; // Accesible externamente gracias a `public`

    function deposit(uint256 amount) public {
        balance += amount; // Modifica el estado
    }

    function getBalance() public view returns (uint256) {
        return balance; // Solo lee el estado
    }

    function calculateBonus(uint256 baseAmount) public pure returns (uint256) {
        return baseAmount * 10 / 100; // Operación pura
    }
}

Buenas Prácticas y Consideraciones

1. Sé explícito con la visibilidad: Declara siempre la visibilidad de tus variables y funciones (public, internal, etc.) para evitar errores y mejorar la legibilidad.

2. Recuerda que todo es público en la blockchain: Aunque declares una variable como private, cualquier persona puede acceder a ella al analizar la blockchain.

Conclusión

Las variables de estado son esenciales para almacenar datos en la blockchain. Junto con las opciones de visibilidad y los modificadores de mutabilidad, ofrecen una manera robusta y flexible de manejar el estado en tus contratos inteligentes.

¿List@ para experimentar con todo lo que hemos aprendido hasta ahora? ¡Prueba a implementar y desplegar algunos ejemplos en Remix! 🚀

Uso Básico de Strings

En Solidity, puedes definir una función que reciba un string como entrada y lo retorne como salida:

contract ExampleContract {
    function echo(string calldata input) public pure returns (string memory) {
        return input;
    }
}

Este tipo de funciones es útil cuando necesitas procesar o retornar información textual.

Concatenación de Strings

Una curiosidad de Solidity, es que no soportaba concatenación de strings hasta febrero de 2022, cuando salió la versión 0.8.12. A partir de esta versión, puedes usar string.concat:

pragma solidity ^0.8.12;

contract ExampleContract {
    function greetUser(string calldata user) public pure returns (string memory) {
        return string.concat("Hello, ", user);
    }
}

Esta es una pequeña muestra de que Solidity está optimizado para manejar números más que texto.

Limitaciones de los Strings

No se pueden indexar

A diferencia de lenguajes como JavaScript o Python, no puedes acceder a un carácter específico en un string mediante indexación:

pragma solidity ^0.8.12;

contract BadContract {
    function getFirstCharacter(string calldata input) public pure returns (string memory) {
        return input[0]; // Esto producirá un error
    }
}

Sin .length

Solidity no permite obtener la longitud de un string directamente con .length. Esto se debe a que los strings son representados como bytes y pueden incluir caracteres Unicode, lo que complica la medición.

Los strings en Solidity tienen algunas limitaciones que dan cuenta de que los smart contracts fueron concebidos en primera instancia para trabajar principalmente con números, no texto. Sin embargo, entender cómo manejarlos te será útil para casos específicos, como mensajes descriptivos o identificadores únicos. 🚀

Ahora ya dominamos los arrays y los strings, y estamos listos para aplicar estas estructuras de datos y aprender más en nuestro camino como blockchain devs, ¡sigamos explorando!

Declaración y Uso Básico de Arrays

En Solidity, se puede declarar un array de dos maneras: de tamaño fijo y dinámico. Un array de tamaño fijo es cuando sabes cuantos elementos va a tener tu array de antemano, y un array dinámico es cuando no lo sabes.

Para declarar un array dinámico de números en Solidity, usamos la notación uint256[]. Aquí hay un ejemplo de una función que toma un array como entrada y simplemente lo retorna:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays01 {
    function useArrayForUint256(
        uint256[] calldata input
    ) public pure returns (uint256[] memory) {
        return input;
    }
}

En Remix, tienes qué ingresar el input en este formato: [1,2,3,4] al llamar esta función. También puedes declrar arrays de cualquier otro tipo, como bool[] o address[] pero los elementos del array siempre tienen qué ser del mismo tipo:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays02 {
    function booleanArrayExample(
        bool[] calldata myArr
    ) public pure returns (bool[] memory) {
        return myArr;
    }

    function addressArrayExample(
        address[] calldata myArr
    ) public pure returns (address[] memory) {
        return myArr;
    }
}

Storage locations: calldata y memory

¡Felicidades por haber llegado hasta aquí! Ahora vamos a ver el primer concepto que es 100% de desarrollo blockchain. Si has estado escribiendo tú mism@ el código ya habrás notado esas palabras clave public, pure, calldata, memory que no hemos explicado. Las primeras dos las vamos a explicar más adelante y por ahora vamos a hablar un poco sobre las últimas dos.

Estoy seguro que sabes lo que es la EVM, es la Ethereum Virtual Machine, el ambiente en donde corre el código que escribimos en Solidity, compilamos a bytecode y desplegamos a la blockchain. Bueno pues la EVM tiene este concepto llamado storage locations, que es justamente los diferentes lugares donde se puede almacenar la data que usan nuestros smart contracts. Las principales storage locations son memory, storage y calldata y tienen diferentes casos de uso para hacer nuestro código más eficiente. Más adelante veremos este concepto de storage locations mucho más a fondo, por ahora agrégalos a tu código para que compile correctamente.

Propiedades y Métodos de Arrays

Indexación

Los arrays son indexados desde cero, como en otros lenguajes de programación. Si intentas acceder a una posición que no existe, la transacción revertirá:

contract Arrays03 {
    uint256[] myArray = [1,2,3,4,5,6];

    function getElementAtIndex(uint256 index) public view returns (uint256) {
        return myArray[index];
    }
}

Longitud

Puedes obtener la longitud de un array con .length y usarla para recorrer el array:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays04 {
    uint256[] myArray = [1, 2, 3, 4, 5, 6];

    function sumOfArrayElements() public view returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < myArray.length; i++) {
            sum += myArray[i];
        }
        return sum;
    }
}

Arrays de Tamaño Fijo

Supongamos que quieres crear un array para un juego donde habrá 4 participantes. Si sabes que solo necesitarás un arreglo con 4 elementos, es mejor declararlo de antemano:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Arrays05 {
    function getLast(
        uint256[5] calldata myArray
    ) public pure returns (uint256) {
        return myArray[4]; // Aquí estamos declarando un array de 4 elementos
    }
}

Si proporcionas como argumento un array de tamaño incorrecto obtendrás un error.

Arrays Anidados

Aunque son muy raros en la práctica, Solidity permite declarar arrays anidados. Aquí hay un ejemplo que busca un número 3 en un array anidado:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract NestedArrayExample01 {
    function containsAThree(
        uint256[][] calldata nestedArray
    ) public pure returns (bool) {
        for (uint256 i = 0; i < nestedArray.length; i++) {
            for (uint256 j = 0; j < nestedArray[i].length; j++) {
                if (nestedArray[i][j] == 3) {
                    return true;
                }
            }
        }
        return false;
    }
}

Puedes probarlo en Remix con este input:
[[1,2,4], [5,6,7], [8,9,10]]
Por supuesto, deberias obtener false.

También puedes declarar arrays anidados con tamaños fijos:

contract NestedArrayExample02 {
    function getLast(
        uint256[2][3] calldata nestedArray
    ) public pure returns (uint256) {
        return nestedArray[2][1];
    }
}

Los arrays son estructuras de datos esenciales en Solidity. Más adelante verás que los usaremos muchísimo en los proyectos que vamos a construir. Mientras tanto, ¡sigamos explorando Solidity! 🚀

If Statements en Solidity

En Solidity, los if statements son casi idénticos a otros lenguajes como JavaScript o Python. Sin embargo, debido a que Solidity es un lenguaje estáticamente tipado, no permite evaluar condiciones dinámicamente.

Por ejemplo, el siguiente código no funcionará:

function isNotZero(uint256 x) public pure returns (bool) {
    if (x) {
        return true;
    } else {
        return false;
    }
}

En Solidity, las condiciones deben ser expresiones booleanas explícitas. Para solucionar este problema, deberías escribir algo como:

function isNotZero(uint256 x) public pure returns (bool) {
    if (x != 0) {
        return true;
    } else {
        return false;
    }
}

Else If

Solidity también soporta el uso de else if, lo que permite manejar múltiples condiciones:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ElseIfExample {
    function max(uint256 a, uint256 b) public pure returns (uint256) {
        if (a > b) {
            return a;
        } else if (b > a) {
            return b;
        } else {
            return 0; // En caso de que sean iguales
        }
    }
}

¿Puedes ver lo que está haciendo el código de arriba?

Solidity no tiene una declaración switch como otros lenguajes.

For Loops en Solidity

Los for loops en Solidity funcionan como en cualquier lenguaje de programación. Puedes utilizarlos para iterar sobre valores numéricos o estructuras de datos (como arrays, que veremos más adelante).

Ejemplo: Suma de Números

Aquí un smart contract que suma los números del 1 al 99:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract ForLoopExample {
    function addNumbers() public pure returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 1; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

Ejercicio: ¿Es un Número Primo?

¿Te gustaría saber si un número es primo? Aquí tienes un ejercicio para implementarlo:

contract IsPrime {
    function isNumberPrime(uint256 num) public pure returns (bool) {
        if (num < 2) return false;

        for (uint256 i = 2; i * i <= num; i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
}

Curiosidades y Limitaciones

Aunque Solidity maneja los for loops naturalmente, hay algunas cosas a tener en cuenta:

• Costos de Gas: Los loops largos pueden consumir demasiado gas, lo que puede hacer que las transacciones fallen. Por ejemplo, evaluar si un número grande como 7877 es primo puede tomar varios segundos debido a los cálculos.

• While y Do While: Estas estructuras de iteración también existen en Solidity pero como practicamente no se usan en el desarrollo real de smart contracts, no las cubriremos aquí.

Los if statements y for loops son herramientas esenciales en Solidity que ofrecen flexibilidad para manejar el flujo lógico de tus smart contracts. Sigamos aprendiendo la sintáxis con paciencia que ya viene lo más interesante.

La práctica nos hace mejores. ¿Qué esperas para probar estos ejemplos en Remix? Intenta agregar edge cases, encontrar maneras de romper el código y casos raros que no hayamos visto. ¡Sigamos explorando! 🚀

Operaciones Básicas

En Solidity, las operaciones básicas como suma, resta, multiplicación y el uso del módulo (%) se comportan de la forma esperada.

Ejemplos

uint256 suma = 10 + 5; // Resultado: 15
uint256 resta = 20 - 10 // Resultado: 10
uint256 multiplicacion = 5 * 10 // Resultado: 50
uint256 exponente = 5 ** 3; // Resultado: 125
uint256 modulo = 10 % 4; // Resultado: 2

¿Quieres probarlo? Aquí hay un contrato con estas operaciones para que lo ejecutes en Remix:

contract Arithmetic01 {
    function sumFunction() public pure returns (uint256) {
        return 10 + 5;
    }

    function substractionFunction() public pure returns (uint256) {
        return 20 - 5;
    }

    function multiplicationFunction() public pure returns (uint256) {
        return 5 * 10;
    }

    function divisionFunction() public pure returns (uint256) {
        return 50 / 2;
    }

    function exponentiationFunction() public pure returns (uint256) {
        return 5 ** 3;
    }

    function moduloFunction() public pure returns (uint256) {
        return 10 % 4;
    }
}

Aritmética de Enteros: Aquí no hay decimales

Una característica crucial de Solidity es que no tiene números de punto flotante (decimales). Esto significa que si intentas dividir 5 / 2, en las versiones recientes de Solidity el compilador te marcará un error:

uint256 division = 5 / 2;
// Error: TypeError: Return argument type rational_const 5 / 2 is not 
// implicitly convertible to expected type (type of first return variable) 
// uint256.

Si necesitas trabajar con porcentajes o fracciones, debes encontrar alternativas. Por ejemplo, para calcular el 15% de 200, no puedes simplemente hacer 200 * .15. En su lugar, puedes escalar el porcentaje y luego dividir:

uint256 porcentaje = (200 * 15) / 100; // porcentaje == 30

Otro ejemplo con decimales. ¿Cómo obtendrias el 7.5% de 200?:

uint256 porcentaje = (200 * 75) / 1000; // porcentaje == 15

Como trivia, esto es así porque la blockchain debe ser determinística, no puede permitir interpretaciones. Por ejemplo si divides 5 / 3 algunas máquinas dirán 1.666666, otras 1.6666667 y esto causaría problemas de consenso en los nodos.

Overflow y underflow

Overflow es cuando una variable trata de contener un número más grande del que puede guardar, y underflow cuando trata de contener un número más pequeño del que puede guardar. Por ejemplo si tenemos uint8 num = 5 sabemos que un uint no puede guardar un número menor a 0, que pasaría si a num le restamos 10? ¡Eso es underflow!

En versiones modernas de Solidity (>= 0.8.0), las operaciones que resultan en underflow u overflow solamente se revierten.

Por ejemplo:

function subtract(uint256 x, uint256 y) public pure returns (uint256) {
    return x - y; // Revertirá si por ejemplo x = 2, y = 5
}

Si x es 2 y y es 5, el programa no retornará -3. En lugar de eso, detendrá su ejecución (hará un revert).

Overflow/underflow controlado: Usando unchecked

Si realmente necesitas permitir overflow o underflow, puedes usar un bloque unchecked:

uint256 x = 2;
uint256 y = 5;

unchecked {
    uint256 z = x - y; // No hará revert
}

Esto no hará revert, y se puede usar en casos muy específicos para ahorrar gas. Como principiante, es bueno que sepas que existe, pero no estarás usandolo pronto.

La próxima vez que escribas un smart contract, recuerda estas reglas. ¡La seguridad y precisión son esenciales en blockchain! Sigamos explorando. 🚀

Por lo pronto, recuerda que en Solidity cada variables es de cierto tipo, vamos a ver los más usados.

Tipos de Datos Más Usados

1. Unsigned Integer (uint256): Números enteros sin signo. Es decir solo podemos guardar el 0 y números positivos (-300 sería un número negativo).

2. Boolean (bool): Variables que almacenan valores true o false.

3. Address (address): Tipo que almacena direcciones de wallets o contratos inteligentes en Ethereum.

Además de estos, Solidity incluye otros tipos como arrays, cadenas (strings) y estructuras (structs), que exploraremos más adelante.

Ejemplo: Funciones con Diferentes Tipos de Retorno

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataTypes01 {
    function getANumber() public pure returns (uint256) {
        uint256 x = 1;
        return x;
    }

    function getABoolean() public pure returns (bool) {
        bool y = true;
        return y;
    }

    function getAnAddress() public pure returns (address) {
        // La wallet de Vitalik Buterin
        address z = 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045;
        return z;
    }

    function getAnotherAddress() public pure returns (address) {
        // Dirección del contrato de USDC
        address z2 = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
        return z2;
    }
}

Observa el código anterior (recuerda intentar escribir tú mism@ el código en Remix y probarlo). En este ejemplo, tenemos 4 funciones, cada una de ellas hace una cosa muy sencilla: guarda un valor hardcodeado en una variable y retorna esta variable.

Nota que siempre tienes qué poner en la firma de la función el tipo de dato que va a retornar tu función. Por ejemplo, intenta agregar esta función a tu código:

    function getAddressFail() public pure returns (bool) {
        return 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    }

Verás que nos da un error porque la firma de tu función dice que va a regresar un bool y está regresando un address.

Address (Dirección)

Recuerda que el tipo address representa una wallet o la dirección de un contrato. Siempre comienzan con 0x más 40 caracteres entre [0-9] y [a-f] (hexadecimal).

Checksum: Las direcciones deben usar un checksum válido para evitar errores. Por ejemplo:

• Dirección sin checksum: 0xd8da6bf26964af9d7eed9e03e53415d37aa96045

• Dirección con checksum: 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045

Si intentas usar una dirección sin checksum en Remix, podrías obtener un error como este:

SyntaxError: This looks like an address but has an invalid checksum.

Por ahora no te preocupes mucho por esto pero es bueno que aprendas a leer los errores. Si por alguna razón no puedes compilar tu código por este error, nota que el mismo Remix te da la versión correcta de la dirección que debes usar, solo lee el mensaje de error y ahí estará la respuesta:

uint256 (Entero sin Signo)

Un uint256 es un entero sin signo que no puede almacenar números negativos. El número 256 indica que puede almacenar valores de hasta 256 bits, es decir, entre 0 y 2^256 - 1, es decir este numerotototote:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataTypes02 {
    function getBiggestNumber() public pure returns (uint256) {
        return
            115792089237316195423570985008687907853269984665640564039457584007913129639935;
    }
}

Si intentas aumentar el último dígito a 6, obtendrás un error porque excede el límite permitido.

Como principiantes, siempre que queramos declarar un número vamos a usar uint256, pero es bueno saber que hay uint8, uint16, uint32, etc.

Boolean (bool)

Un bool almacena únicamente dos valores posibles: true o false. Es un tipo de dato básico y muy similar al de otros lenguajes de programación.

¡Ahora ya conoces los tipos de datos más comunes en Solidity! Recuerda practicar estos conceptos, probar el código en Remix y testear cualquier cosa que te dé curiosidad. Ahora sigamos explorando. 🚀

¿Qué es Remix?

Remix es una herramienta que nos permite escribir, compilar, y desplegar smart contracts directamente desde nuestro navegador. Tiene un editor de código integrado y herramientas como un compilador, una consola y un simulador de una blockchain virtual que nos permitirá aprender muchísimo sin siquiera tener qué conectar nuestra wallet. ¡Un entorno perfecto para nosotros que estamos comenzando!

Primeros Pasos con Remix: Escribiendo tu Primer Contrato

¡Pongamos manos a la obra! Y como dictan las buenas costumbres, crearemos un contrato llamado Hello World, este contrato contendrá dos funciones que retornan datos básicos.

Paso 1: Crea un nuevo archivo .sol

1. Ve a remix.ethereum.org. Es muy importante que te asegures que estás en la dirección correcta. ¡Ten cuidado con estafas!

2. En el panel lateral izquierdo, haz clic en File Explorer y crea un archivo nuevo llamado HelloWorld.sol. La extensión .sol indica que es un archivo de Solidity.

Paso 2: Escribe el Contrato

Copia y pega el siguiente código dentro del archivo HelloWorld.sol:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract HelloWorld {
    function helloWorld() public pure returns (uint256) {
        return 100;
    }

    function returnsBool() public pure returns (bool) {
        return true;
    }
}

Verás una advertencia de que tengas cuidado con el código que pegues. Puedes leerla y aceptarla.

Este contrato define dos funciones simples:

• helloWorld(): Retorna el número 100.

• returnsBool(): Retorna el valor booleano true.

Compilando tu Contrato

Paso 1: Seleccionar el Compilador

1. En el panel izquierdo de Remix, haz clic en la pestaña Solidity Compiler.

2. Asegúrate de que la versión del compilador coincida con la versión declarada en el contrato (pragma solidity ^0.8.0;), Normalmente Remix se encarga de esto en automático, pero para que sepas cualquier versión del compilador que empiece con 0.8.x funcionará.

3. Haz clic en Compile HelloWorld.sol.

Si todo está correcto, deberías ver un checkmark verde en el ícono del compilador.

Desplegando el Contrato en Remix

Remix incluye una red virtual que simula el comportamiento de una blockchain real. Así puedes desplegar y probar tu contrato sin necesidad de usar dinero real, conectar tu wallet o buscar fondos de testnet en un faucet (si no entiendes estos términos, no te preocupes los veremos más adelante).

Paso 1: Acceder al Desplegador

1. Ve a la pestaña Deploy & Run Transactions en el panel izquierdo.

2. Asegúrate de que el Environment esté configurado en "Remix VM" (no importa que diga Cancun o London o cualquier otra versión).

Paso 2: Desplegar el Contrato

1. Bajo la sección "Deploy", selecciona el contrato HelloWorld.

2. Haz clic en el botón naranja Deploy.

Una vez desplegado, verás el contrato listado bajo la sección "Deployed Contracts" y verás una palomita verde en la consola indicando que la transacción fue exitosa.

Probando el Contrato

1. Expande el contrato en "Deployed Contracts".

2. Haz clic en las funciones helloWorld y returnsBool para ejecutarlas.

3. Observa cómo retornan los valores 100 y true, respectivamente.

¡Felicidades! Has dado tus primeros pasos como desarrollador/a blockchain, sigamos adelante. 🚀

¿Qué es Hardhat? Componentes principales

Primero que nada, es importante saber que Hardhat es un grupo de herramientas con diferentes utilidades:

Hardhat Runner: Es el componente principal de Hardhat, es un task runner que nos ayuda con todas las tareas relacionadas al desarrollo blockchain.

Hardhat Network: Es un simulador de un nodo local de la red de Ethereum, nos permite emular la blockchain y hacer pruebas locales en nuestra computadora.

Hardhat Ignition: Es un sistema nuevo para hacer más fluido el proceso de desplegar nuestros contratos.

Extensión de VS Code: Hardhat creó una extensión de VS Code que es la más recomendada. Mírala en su página oficial.

Hardhat Chai Matchers: Chai es una librería de pruebas muy usada en el ecosistema de JavaScript. Hardhat añade funcionalidad específica de blockchain para que escribamos mejores tests de nuestros contratos.

Entonces, ya sabemos que Hardhat es un set de herramientas y la principal es su task runner. Un "task runner" es una herramienta que permite automatizar tareas repetitivas, como compilar código, ejecutar pruebas o desplegar contratos inteligentes. Todo en Hardhat gira en torno a los conceptos de tareas y plugins. Cuando compilamos o desplegamos nuestros contratos, estamos corriendo tareas. Hardhat nos permite crear nuestras propias tareas y crear flujos bastante avanzados con ellas.

Instalando Hardhat

Ahora sí viene lo bueno, ¡vamos a programar!

Empecemos creando un nuevo folder en una carpeta donde tengas tus proyectos de código:

mkdir hardhat-prueba cd hardhat-prueba

Dentro de este folder, inicializamos un proyecto de npm corriendo:

npm init -y

A continuación instalamos Hardhat como dependencia de desarrollo (también puedes usar yarn, pero se recomienda usar npm 7 o posterior):

npm install --save-dev hardhat

Nota: La documentación de Hardhat recomienda que si estamos en Windows usemos WSL pero yo hice pruebas en el sistema normal de Windows y no tuve ningún problema.

Ahora iniciemos un proyecto muestra corriendo:

npx hardhat init

Seleccionemos ‘Create JavaScript project’ y demos Enter en las demás preguntas. (Para poder seleccionar necesitas una terminal interactiva, si estás en Windows, GitBash no te servirá para este paso, te recomiendo usar PowerShell):

Como dijimos antes, el concepto principal en Hardhat son las tareas, así que corre npx hardhat y veras algunas de las tareas disponibles. Por ejemplo 3 de las tareas que vamos a usar muy seguido serán compile, test y node. Cuando instalemos algún plugin, éste nos hará disponibles nuevas tareas que podremos ver también en esta lista.

Nuestro flujo de trabajo será así: 1) Escribir un contrato inteligente, 2) Escribir tests para este contrato y 3) Desplegar nuestro contrato a una blockchain

Escribiendo y compilando el smart contract

Cuando corrimos npx hardhat init se creó un contrato de prueba en contracts/Lock.sol. Te recomiendo que leas con detenimiento el código para que entiendas lo que hace y cómo lo hace:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
    }

    function withdraw() public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
    }
}

El siguiente paso es compilar nuestro contrato, para esto corremos npx hardhat compile. Si todo salió bien veremos este output:

Compiled 1 Solidity file successfully (evm target: paris).

Testeando nuestro contrato

Hardhat ya viene con Mocha, Chai y una versión especial de Ethers.js para probar todo lo que necesitamos. En otro artículo vamos a aprender más sobre crear pruebas para nuestros contratos pero por ahora, puedes ver que ya tenemos un archivo con varias pruebas en test/Lock.js. Te recomiendo que le eches un vistazo para que te familiarices con cómo se ve un archivo de pruebas de un smart contract en JavaScript.

A continuación, corre las pruebas: npx hardhat test y verás un mensaje de que todas las pruebas pasaron correctamente.

Desplegando con Hardhat Ignition

¡Genial! Ya que escribimos y probamos a fondo nuestros contratos inteligentes, estamos listos para desplegarlos a una red. Por ahora vamos a usar Ignition y en otro artículo vamos a ver a fondo todas las opciones para customizar nuestros despliegues.

Si vas a la carpeta ignition/modules/Lock.js verás este código:

// This setup uses Hardhat Ignition to manage smart contract deployments.
// Learn more about it at https://hardhat.org/ignition

const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");

const JAN_1ST_2030 = 1893456000;
const ONE_GWEI = 1_000_000_000n;

module.exports = buildModule("LockModule", (m) => {
  const unlockTime = m.getParameter("unlockTime", JAN_1ST_2030);
  const lockedAmount = m.getParameter("lockedAmount", ONE_GWEI);

  const lock = m.contract("Lock", [unlockTime], {
    value: lockedAmount,
  });

  return { lock };
});

Así que ahora corre el siguiente comando:

npx hardhat ignition deploy ./ignition/modules/Lock.js

y verás algo así:

Como te diste cuenta, este despliegue se hizo a una red local simulada que Hardhat creó ‘en el instante’ para hacer el proceso de despliegue.

Conclusión y próximos pasos

Así que ahora ya sabes cómo crear un proyecto de Hardhat, compilar contratos inteligentes, testearlos con JavaScript y desplegarlos a una red local, ¡gran trabajo!

En el siguiente artículo de esta serie te mostraré cómo desplegar a cualquier red de prueba (testnet) y mainnet de manera segura ¡vamos!

1. Master the Fundamentals

Before diving into advanced topics, build a strong foundation:

• Blockchain Basics:

  • Understand how blockchains work (consensus mechanisms, cryptography, smart contracts, and decentralization).

  • Study the history and principles of Bitcoin and Ethereum.

• Core Programming Skills:

  • Proficiency in JavaScript/TypeScript for web development.

  • Learn Solidity (the primary language for Ethereum smart contracts).

  • Explore other blockchain languages like Rust (for Solana) or Go.

• Key Tools and Frameworks:

  • Familiarize yourself with Foundry, Hardhat, and Remix for Ethereum development.

  • Explore libraries like viem for interacting with the blockchain.

2. Specialize in Key Blockchain Areas

Being a generalist is valuable, but becoming an expert in a niche area can set you apart.

Specialization Options:

• Smart Contract Development:

  • Learn advanced Solidity topics (gas optimization, security, DeFi protocols).

  • Master ERC standards (ERC-20, ERC-721, ERC-1155).

  • Build and audit smart contracts.

• DeFi and Financial Protocols:

  • Study AMMs (e.g., Uniswap), lending protocols (e.g., Aave), and derivatives.

  • Understand tokenomics and stablecoins.

  • Experiment with flash loans and on-chain arbitrage.

• Layer 2 Solutions:

  • Study Optimistic Rollups (e.g., Arbitrum) and zkRollups (e.g., zkSync, StarkNet).

  • Learn how to deploy contracts on Layer 2 chains.

• NFTs and Gaming:

  • Explore the ERC-721 and ERC-1155 standards.

  • Build marketplaces, NFT minting platforms, or play-to-earn games.

• Blockchain Infrastructure:

  • Dive into consensus mechanisms, nodes, and validators.

  • Contribute to core protocol development or create custom chains with Substrate or Cosmos SDK.

• Privacy and Zero-Knowledge Proofs:

  • Learn about zk-SNARKs, zk-STARKs, and their applications.

  • Experiment with zk-friendly programming languages (e.g., Circom).

3. Build Projects and Gain Practical Experience

Practical experience is crucial to becoming a top developer:

• Start Small:

  • Build simple decentralized applications (dApps) like token wallets or crowdfunding platforms.

  • Gradually increase complexity by creating DeFi or NFT projects.

• Open Source Contributions:

  • Contribute to popular blockchain projects (e.g., Ethereum, Uniswap, OpenZeppelin).

  • Get involved in the community by solving issues and adding features.

• Hackathons:

  • Participate in blockchain hackathons (e.g., EthGlobal, Encode Club) to build real-world projects and network with other developers.

4. Deepen Your Theoretical Knowledge

To truly stand out, develop a deep understanding of the underlying technology:

• Cryptography:

  • Study elliptic curve cryptography, hashing algorithms, and digital signatures.

• Distributed Systems:

  • Learn about consensus algorithms (e.g., Proof of Work, Proof of Stake, PBFT).

  • Understand the challenges of scalability, latency, and fault tolerance.

• Tokenomics:

  • Dive into game theory and incentive mechanisms.

  • Study successful token models and experiment with creating your own.

5. Stay Updated with Industry Trends

Blockchain is a fast-evolving field. Stay current with the latest developments:

• Read Whitepapers:

  • Analyze whitepapers of key protocols (e.g., Ethereum, Solana, Polkadot).

• Follow Thought Leaders:

  • Follow Vitalik Buterin, Balaji Srinivasan, and other blockchain pioneers on Twitter.

• Engage in the Community:

  • Join forums, Discords, and DAOs related to blockchain development.

  • Attend conferences like Devcon or ETHDenver.

6. Build Your Personal Brand

Being recognized as an authority in the space can open doors:

• Share Knowledge:

  • Write blogs, create YouTube tutorials, or publish guides on blockchain topics.

  • Teach others through workshops or bootcamps.

• Create a Portfolio:

  • Showcase your projects on GitHub with detailed READMEs.

  • Build a personal website to display your blockchain expertise.

• Network Actively:

  • Collaborate with other developers and join blockchain communities.

  • Seek mentorship from experienced blockchain engineers.

7. Develop a Long-Term Vision

Think beyond just writing code:

• Innovate:

  • Identify gaps in the blockchain ecosystem and build solutions to address them.

• Leadership:

  • Start your own blockchain project, protocol, or company.

  • Mentor junior developers and contribute to growing the blockchain ecosystem.

• Continuous Learning:

  • Blockchain technology evolves rapidly. Stay curious and committed to learning new tools, frameworks, and protocols.

Aquí está una versión editada y pulida del texto:

Resources

• Cyfrin Updraft: I highly recommend starting with this platform, as it contains everything you need to begin your journey.

• RareSkills Solidity Course: A free collection of articles ranging from basic concepts to in-depth studies on advanced topics.

• Solidity by Example: Great for reinforcing your theoretical understanding of the language.

• Solidity Docs: There’s nothing better than reading the official documentation and using it as your primary reference.

Finally, here are some tips I’ve received from people who have already walked this path:

1. Start learning the basics with Remix—it’s a great environment for beginners.

2. If you’re deciding between Hardhat and Foundry, choose Foundry.

3. If you need to use Hardhat, opt for viem over Ethers.js or Web3.js.

4. Don’t wait too long to start building projects and joining hackathons. EthGlobal hackathons are amazing if you can attend one in person, but there are plenty of online hackathons too.

5. Two great Layer 2 solutions to focus on and learn are Arbitrum and Base.

And most importantly, take it one step at a time. This is a multi-year journey, and as the saying goes: "The path to mastering the craft is long, and life is short." But we must strive to be the best at what we’re passionate about. Let’s keep exploring the frontier!

1. Domina los Fundamentos 🔗

Antes de adentrarte en temas avanzados, construye una base sólida:

• Conceptos Básicos de Blockchain:

  • Aprende cómo funcionan las blockchains (mecanismos de consenso, criptografía, contratos inteligentes, descentralización).

  • Estudia la historia y principios de Bitcoin y Ethereum.

• Habilidades de Programación Esenciales:

  • Domina JavaScript/TypeScript para desarrollo web.

  • Aprende Solidity, el lenguaje principal para contratos inteligentes en Ethereum.

  • Explora otros lenguajes como Rust (para Solana) o Go

• Herramientas y Frameworks Clave:

  • Familiarízate con Foundry, Hardhat y Remix para el desarrollo en Ethereum.

2. Especialízate en Áreas Clave de Blockchain 🔍

Ser generalista es útil, pero convertirte en un experto en un área específica puede diferenciarte.

Opciones de Especialización:

• Desarrollo de Contratos Inteligentes:

  • Aprende temas avanzados de Solidity (optimización de gas, seguridad, protocolos DeFi).

  • Domina los estándares ERC (ERC-20, ERC-721, ERC-1155).

  • Construye y audita contratos inteligentes.

• DeFi y Protocolos Financieros:

  • Estudia AMMs (ej. Uniswap), protocolos de préstamos (ej. Aave) y derivados.

  • Aprende sobre tokenomics y stablecoins.

  • Experimenta con flashloans y arbitraje en la blockchain.

• Soluciones de Capa 2:

  • Investiga rollups optimistas (ej. Arbitrum) y zkRollups (ej. zkSync, StarkNet).

  • Aprende a desplegar contratos en cadenas de Capa 2.

• NFTs y Gaming:

  • Explora los estándares ERC-721 y ERC-1155.

  • Construye marketplaces, plataformas de minteo de NFTs o juegos play-to-earn.

• Infraestructura Blockchain:

  • Aprende sobre nodos, validadores y mecanismos de consenso.

  • Contribuye al desarrollo de protocolos base o crea blockchains personalizadas con Substrate o Cosmos SDK.

• Privacidad y Pruebas de Conocimiento Cero:

  • Estudia zk-SNARKs, zk-STARKs y sus aplicaciones.

  • Experimenta con lenguajes como Circom para programar pruebas de conocimiento cero.

3. Construye Proyectos y Gana Experiencia Práctica 👷

La experiencia práctica es esencial.

• Comienza con Proyectos Sencillos:

  • Construye aplicaciones descentralizadas simples (dApps) como wallets de tokens o plataformas de crowdfunding.

  • Aumenta la complejidad creando proyectos DeFi o NFTs.

• Contribuciones Open Source:

  • Contribuye a proyectos blockchain populares (ej. Ethereum, Uniswap, OpenZeppelin).

  • Participa en las comunidades resolviendo problemas y añadiendo funcionalidades.

• Participa en Hackathones:

  • Únete a hackathones blockchain (ej. EthGlobal, Encode Club) para desarrollar proyectos reales y hacer networking.

4. Profundiza en el Conocimiento Teórico 📚

Para ser verdaderamente destacado, comprende la tecnología subyacente:

• Criptografía:

  • Estudia criptografía de curvas elípticas, algoritmos de hash y firmas digitales.

• Sistemas Distribuidos:

  • Aprende sobre algoritmos de consenso (ej. Proof of Work, Proof of Stake, PBFT).

  • Comprende los desafíos de escalabilidad, latencia y tolerancia a fallos.

• Tokenomics:

  • Sumérgete en la teoría de juegos y mecanismos de incentivos.

  • Analiza modelos de tokens exitosos y experimenta creando los tuyos.

5. Mantente Actualizado con las Tendencias📈

El mundo blockchain evoluciona rápidamente. Mantente al día:

• Lee Whitepapers:

  • Analiza los whitepapers de protocolos clave (ej. Ethereum, Solana).

• Sigue a Líderes de Opinión:

  • Sigue a Vitalik Buterin, Balaji Srinivasan y otros pioneros en Twitter.

• Involúcrate en la Comunidad:

  • Únete a foros, grupos de Discord y DAOs relacionados con blockchain.

  • Asiste a conferencias como Devcon o ETHDenver.

6. Construye tu Marca Personal 👨‍🎤

Ser reconocido como una autoridad en el espacio abrirá muchas puertas:

• Comparte Conocimiento:

  • Escribe blogs, crea tutoriales en YouTube o publica guías.

  • Enseña a otros a través de talleres o bootcamps.

• Crea un Portafolio:

  • Muestra tus proyectos en GitHub con READMEs detallados.

  • Construye un sitio web personal para exhibir tu experiencia en blockchain.

• Haz Networking Activo:

  • Colabora con otros desarrolladores y únete a comunidades blockchain.

  • Busca mentores entre ingenieros blockchain experimentados.

7. Desarrolla una Visión a Largo Plazo 🛣️

Piensa más allá del código:

• Innova:

  • Identifica brechas en el ecosistema blockchain y construye soluciones para abordarlas.

• Liderazgo:

  • Lanza tu propio proyecto blockchain.

  • Mentorea a desarrolladores junior y contribuye al crecimiento del ecosistema blockchain.

• Aprendizaje Continuo:

  • La tecnología blockchain evoluciona rápido. Mantente curioso y comprometido a aprender nuevas herramientas, frameworks y protocolos.

Recursos

- Cyfrin Updraft: Recomendaría empezar con esta plataforma que contiene todo lo que necesitas para empezar.
- RareSkills Solidity Course: Esta es una colección gratuita de artículos desde cosas básicas hasta estudios a profundidad sobre temas muy avanzados.
- Solidity by Example: Bueno para reforzar tu conocimiento teórico del lenguaje.
- Solidity Docs: No hay nada que reemplace leer la documentación y consultarla siempre como referencia.

Por último, algunos consejos que me han dado personas que ya pasaron este camino:

• Empieza a aprender lo básico con Remix.

• Si tienes qué elegir entre Hardhat o Foundry, elije Foundry.

• Si tienes qué usar Hardhat, elije viem sobre Ethers.js o Web3.js.

• No tardes mucho en empezar a crear proyectos y unirte a hackathones, los de EthGlobal son geniales si puedes ir a uno en persona, pero si no, hay muchísimos hackathones online.

• Dos L2s buenas para enfocarse y aprender son Arbitrum y Base.

Y finalmente, tómalo con calma, es un plan a varios años, ‘el camino de dominar el oficio es largo y la vida es breve’ pero debemos intentar ser las y los mejores en lo que nos apasiona. Sigamos explorando la frontera!

Arbitrum entonces es una suite de tecnologías creadas para escalar Ethereum.

Como sabes, Ethereum es una gran tecnología pero tiene un problema muy grande: Solo puede procesar de 20 a 40 transacciones por segundo (TPS), lo cual no es suficiente para los miles de usuarios diarios que tiene, y menos si queremos que cientos de millones de personas la usen.

Aquí es donde entra el blockchain trilema, y las Layer 2, que son cadenas creadas para trabajar encima de una blockchain principal y hacerla más rápida, segura y/o eficiente (hacerla más escalable). Si quieres más información a detalle, te recomiendo leer este artículo.

Como ya sabes entonces, los rollups son una de las principales tecnologías L2, y hay 2 tipos de rollups: Optimistic y Zero-knowledge.

Ahora, vamos a entender las diferencias entre Arbitrum One, Arbitrum Nova, Nitro y otros términos.

Seguramente sabes que para que Ethereum funcione, la gente necesita correr nodos, y para correr estos nodos utilizan un software especial, conocido como un cliente. Uno de los más conocidos en Ethereum se llama Geth. De manera similar, para correr un nodo en Arbitrum se necesita un software especial llamado Nitro, que a su vez, está basado en Geth.

Después tenemos que Arbitrum tiene dos protocolos innovadores para diferentes necesidades de quienes construyen aplicaciones descentralizadas (dapps), el Arbitrum Rollup Protocol y el Arbitrum AnyTrust Protocol.

El producto principal de Arbitrum se llama Arbitrum Rollup, es un optimistic rollup y más adelante vamos a ver todos los detalles sobre su funcionamiento. Por ahora, basta con saber que la arquitectura de Arbitrum Rollup lo hace una L2 sumamente segura e ideal para casos de uso como DeFi.

Por otro lado, algunas aplicaciones tienen otros casos de uso que requieren manejar muchas transacciones y pueden permitirse algunas concesiones de seguridad para ahorrar costos. Para estas aplicaciones, como juegos o redes sociales, existe Arbitrum AnyTrust, la cual también exploraremos a fondo en artículos posteriores.

Un ejemplo de implementación del Arbitrum Rollup Protocol es la cadena Arbitrum One, que es el producto bandera de Arbitrum. Y un ejemplo de implementación del protocolo AnyTrust es la cadena Arbitrum Nova.

Por si esto no fuera suficiente, cualquier developer puede lanzar su propia cadena L3 encima de Nova o de One, y para esto utilizarían Arbitrum Orbit.

Finalmente, una de las soluciones más esperadas por la comunidad se llama Stylus, una herramienta que le permite a cualquier desarrollador/a escribir contratos inteligentes en cualquier lenguaje que compile a WebAssembly como por ejemplo, C, C++ y por supuesto Rust! ¿Muy cool, no? Personalmente, no puedo esperar a adentrarme más en estas tecnologías.

Conclusión

Espero que esta pequeña introducción te haya servido para entender mejor las diferencias entre Arbitrum One, Arbitrum Nova, Stylus y más soluciones de la suite de tecnología de Arbitrum. Si algo no te quedó muy claro mándame un mensaje en X y te puedo ayudar a aclararlo, mientras tanto ¡sigamos explorando y construyendo en Arbitrum!

Cómo Instalar Foundry para Mac y Windows

Foundry es un conjunto de herramientas avanzadas para el desarrollo de contratos inteligentes y aplicaciones descentralizadas en Ethereum. En esta guía, te mostramos cómo instalar Foundry en Mac y en Windows. Para Windows, es necesario configurar el Subsistema de Windows para Linux (WSL) antes de la instalación. Este sistema nos permitirá tener un entorno de Linux de manera casi instantánea y la instalación de Foundry será mucho más sencilla.

Instalación en Mac

1. Instalar Homebrew (si no lo tienes instalado)

Homebrew es un gestor de paquetes para macOS que facilita la instalación de software. Para instalarlo, abre la terminal y ejecuta el siguiente comando:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Instalar las dependencias de Foundry

Ejecuta el siguiente comando para instalar las herramientas necesarias, como curl y git:

brew install curl git

3. Instalar Foundry

Para instalar Foundry, ejecuta el siguiente comando en la terminal:

curl -L https://foundry.paradigm.xyz | bash

Este comando descarga y ejecuta el script de instalación de Foundry. El script configurará la herramienta por ti.

4. Configurar Foundry

Después de instalar Foundry, debes ejecutar el siguiente comando para inicializar las herramientas de Foundry:

foundryup

Este comando descargará e instalará las últimas versiones de Foundry, Forge y Cast.

5. Verificar la instalación

Para asegurarte de que Foundry esté instalado correctamente, ejecuta el siguiente comando:

forge --version

Si ves la versión de Foundry en la terminal, la instalación fue exitosa.

Instalación en Windows

1. Instalar el Subsistema de Windows para Linux (WSL)

Para usar Foundry en Windows, primero debes instalar WSL, lo que te permitirá usar un entorno de Linux dentro de Windows.

1.1 Habilitar WSL

Abre una terminal de PowerShell como administrador y ejecuta el siguiente comando:

wsl --install

Este comando instalará WSL 2 junto con Ubuntu como la distribución predeterminada. Si ya tienes WSL instalado, puedes actualizar a WSL 2 con el siguiente comando:

wsl --set-default-version 2

1.2 Reiniciar el sistema

Una vez que WSL esté instalado, se te pedirá que reinicies tu computadora.

1.3 Configurar WSL

Después de reiniciar, abre PowerShell nuevamente y ejecuta el siguiente comando para asegurarte de que Ubuntu sea tu distribución predeterminada:

wsl --set-default ubuntu

2. Instalar las dependencias en WSL

Abre la terminal de Ubuntu dentro de WSL e instala las dependencias necesarias para Foundry, como curl y git:

sudo apt update
sudo apt install curl git build-essential

3. Instalar Foundry

Dentro de la terminal de Ubuntu, ejecuta el siguiente comando para instalar Foundry:

curl -L https://foundry.paradigm.xyz | bash

4. Configurar Foundry

Después de la instalación, ejecuta el siguiente comando para configurar Foundry y sus herramientas:

foundryup

5. Verificar la instalación

Por último, verifica que Foundry esté instalado correctamente con el siguiente comando:

forge --version

Si todo salió bien, verás la versión de Forge en la terminal.

Conclusión

Ya sea en macOS o Windows, con estos pasos podrás tener Foundry instalado y listo para usar. Esto nos permitirá usar las mismas librerías y software que utilizan los profesionales para desarrollar dapps a la vez que podremos trabajar en los ejercicios de la guía que estaremos siguiendo y podremos verificar si los ejercicios están bien hechos. Para Windows, recuerda que primero debes configurar WSL para trabajar en un entorno Linux. Ahora puedes comenzar a desarrollar tus proyectos de contratos inteligentes con Foundry.

Para aprender lo básico de Solidity hay una sola herramienta que nos permitirá hacer todo en línea sin preocuparnos de nada más. Esta herramienta se llama Remix:

remix.ethereum.org

Asegúrate siempre de estar en esa URL y no en otra que esté tratando de hacerse pasar por Remix.

Este será nuestro primer contrato inteligente:

contract HelloWorldContract {

    function helloWorld() public pure returns (uint256) {
            return 100;
    }

    function returnBool() public pure returns (bool) {
            return true;
    }
}

Adentro de Remix, haz click derecho en contracts y luego en New File. Todos los archivos de Solidity deben tener la extensión .sol, así que llamemos este archivo HelloWorld.sol. Ahora copia y pega el código de arriba, o trata de escribirlo tú mismo.

El siguiente paso es compilar el código para lo cual solo tenemos qué hacer CTRL + S.

Ahora, hay qué dar click en el símbolo de Ethereum en el menú de la izquierda, y click en el botón naranja que dice Deploy.

Si hiciste todo bien, en la parte de abajo, justo debajo de donde dice Deployed/Unpinned Contracts encontrarás tu contrato desplegado en una blockchain virtual, y podrás interactuar con él.

Verás un botón azul que dice helloWorld y otro que dice returnBool. Haz click en ellos y ve lo que resulta de darles click. Ahora haz hecho tu primer smart contract en Remix!

Fuente: Artículo de Rare Skills