Merge branch 'main' of https://github.com/AmazingAng/WTF-Solidity

.codespellignore

@@ -1,2 +1,3 @@
 te
-loath
+loath
+amountIn

Languages/en/48_TransparentProxy_en/TransparentProxy.sol

@@ -28,7 +28,7 @@ contract TransparentProxy {
     }
 
     // fallback function, delegates function call to logic contract
-    // can not be called by admin, to avoid causing unexpected beahvior due to selector clash
+    // can not be called by admin, to avoid causing unexpected behavior due to selector clash
     fallback() external payable {
         require(msg.sender != admin);
         (bool success, bytes memory data) = implementation.delegatecall(msg.data);

Languages/en/48_TransparentProxy_en/readme.md

@@ -81,7 +81,7 @@ contract TransparentProxy {
     }
 
     // fallback function, delegates function call to logic contract
-    // can not be called by admin, to avoid causing unexpected beahvior due to selector clash
+    // can not be called by admin, to avoid causing unexpected behavior due to selector clash
     fallback() external payable {
         require(msg.sender != admin);
         (bool success, bytes memory data) = implementation.delegatecall(msg.data);

Languages/es/03_Funcion_es/readme.md

@@ -160,7 +160,7 @@ Aquí definimos una función `internal minus()`, `number` disminuirá en 1 cada
     }
 ```
 
-Definimos una función `external payable minusPayable()`, la cual llama a `minus()` y devuelve el `balance de ETH` del contrato actual (la palabra clave`this` nos permite consultar la dirección del contrato actual). Dado que la función es `payable`, podemos enviar 1 `ETH` al contrato al llamar a `minusPayable()`.
+Se define una función `external payable minusPayable()`, la cual llama a `minus()` y devuelve el `balance de ETH` del contrato actual (la palabra clave `this` permite consultar la dirección del contrato actual). Dado que la función es `payable`, se puede enviar 1 `ETH` al contrato al llamar a `minusPayable()`.
 
 ![](./img/3-5.png)
 
@@ -173,4 +173,4 @@ Podemos ver que el balance del contrato es 1 `ETH` en el mensaje de retorno.
 
 ## Resumen
 
-En esta sección, introducimos el tipo de función en `Solidity`. Las palabras clave `pure` y `view` son difíciles de entender, ya que no son comunes en otros lenguajes de programación. No necesitas pagar tarifas de gas por llamar a funciones `pure` o `view`, ya que no modifican los datos en la cadena de bloques.
+En esta sección, introducimos el tipo de función en `Solidity`. Las palabras clave `pure` y `view` son difíciles de entender, ya que no son comunes en otros lenguajes de programación. No necesitas pagar tarifas de gas por llamar a funciones `pure` o `view`, ya que no modifican los datos en la cadena de bloques.

Languages/es/13_Herencia_es/readme.md

@@ -141,7 +141,7 @@ contract Identifier is Base1 {
 }
 ```
 
-El contrato `Identifier` puede usar directamente el modificador `exactDividedBy2And3`, por que hereda del contrato `Base1`. También podemos reescribir el modificador del contrato.
+El contrato `Identifier` puede usar directamente el modificador `exactDividedBy2And3`, por que hereda del contrato `Base1`. También se puede reescribir el modificador del contrato.
 
 ```solidity
     modifier exactDividedBy2And3(uint _a) override {

Languages/es/14_Interfaces_es/readme.md

@@ -111,9 +111,9 @@ interface IERC721 is IERC165 {
 
 
 ### ¿Cuándo usar una interfaz?
-Si sabemos que un contrato implementa la interfaz `IERC721`, podemos interactuar con él sin conocer su implementación detallada.
+Si sabe que un contrato implementa la interfaz `IERC721`, se puede interactuar con él sin conocer su implementación detallada.
 
-El Bored Ape Yacht Club `BAYC` es un NFT `ERC721` que implementa todas las funciones de la interfaz `IERC721`. Podemos interactuar con el contrato `BAYC` con la interfaz `IERC721` y su dirección de contrato, sin conocer su código fuente.
+El Bored Ape Yacht Club `BAYC` es un NFT `ERC721` que implementa todas las funciones de la interfaz `IERC721`. Se puede interactuar con el contrato `BAYC` con la interfaz `IERC721` y su dirección de contrato, sin conocer su código fuente.
 Por ejemplo, se puede usar `balanceOf()` para consultar el saldo de `BAYC` de una dirección, o usar `safeTransferFrom()` para transferir un NFT `BAYC`.
 
 

Languages/es/15_Errores_es/readme.md

@@ -31,7 +31,7 @@ Solidity tiene muchas funciones para el manejo de errores. Los errores pueden oc
 
 ### Error
 La declaración `error` es una característica nueva en solidity `0.8`. Ahorra gas e informa a los usuarios por qué la operación falló. Es la manera recomendada de lanzar un error en Solidity.
-Los errores personalizados se definen utilizando la declaración de error, que se puede usar dentro y fuera de los contratos. A continuación, creamos un error `TransferNotOwner`, que lanzará un error cuando el usuario que realice la transacción no sea el `propietario` del token.
+Los errores personalizados se definen utilizando la declaración de error, que se puede usar dentro y fuera de los contratos. A continuación, se crea un error `TransferNotOwner`, que lanzará un error cuando el usuario que realice la transacción no sea el `propietario` del token.
 
 ```solidity
 error TransferNotOwner(); // error personalizado
@@ -93,7 +93,7 @@ Después de desplegar el contrato `Error`.
 
     ![15-1.png](./img/15-1.png)
 
-2. `require`: Ingrese un número `uint256` y una dirección no cero, y llame la función `transferOwner2()`. La consola lanzará un error y mostrará el mensaje de error `"El usuario no es el propietario del token"`.
+2. `require`: Ingrese un número `uint256` y una dirección no cero, y llame la función `transferOwner2()`. La consola lanzará un error y  se mostrará el mensaje de error `"El usuario no es el propietario del token"`.
 
     ![15-2.png](./img/15-2.png)
 
@@ -114,4 +114,4 @@ Se puede ver que `error` consume menos gas, seguido por `assert`, mientras que `
 Por lo tanto, `error` no solo informa al usuario sobre el mensaje del error, sino que también ahorra gas.
 
 ## Resumen
-En este capítulo, introdujimos 3 declaraciones para manejar errores en Solidity: `error`, `require` y `assert`. Después de comparar su consumo de gas, la declaración `error` es la más barata, mientras que `require` tiene el consumo de gas más alto. 
+En este capítulo, Se introdujo 3 declaraciones para manejar errores en Solidity: `error`, `require` y `assert`. Después de comparar su consumo de gas, la declaración `error` es la más barata, mientras que `require` tiene el consumo de gas más alto. 

Languages/es/16_Sobrecarga_es/Overloading.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.21;
+    contract Overload {
+    function saySomething() public pure returns(string memory){
+        return("Nothing");
+    }
+
+    function saySomething(string memory something) public pure returns(string memory){
+        return(something);
+    }
+
+    function f(uint8 _in) public pure returns (uint8 out) {
+        out = _in;
+    }
+
+    function f(uint256 _in) public pure returns (uint256 out) {
+        out = _in;
+    }
+}

Languages/es/16_Sobrecarga_es/readme.md

@@ -0,0 +1,73 @@
+---
+Título: 16. Sobrecarga
+tags:
+  - solidity
+  - advanced
+  - wtfacademy
+  - overloading
+---
+# Tutorial WTF Solidity: 16. Sobrecarga
+
+Recientemente, he estado revisando Solidity y escribiendo tutoriales en "WTF Solidity" para principiantes.
+
+Twitter: [@0xAA_Science](https://twitter.com/0xAA_Science) | [@WTFAcademy_](https://twitter.com/WTFAcademy_)
+
+Comunidad: [Discord](https://discord.gg/5akcruXrsk)｜[Wechat](https://docs.google.com/forms/d/e/1FAIpQLSe4KGT8Sh6sJ7hedQRuIYirOoZK_85miz3dw7vA1-YjodgJ-A/viewform?usp=sf_link)｜[Sitio web wtf.academy](https://wtf.academy)
+
+La traducción al español ha sido realizada por Jonathan Díaz con el objetivo de hacer estos recursos accesibles a la comunidad de habla hispana.
+
+Twitter: [@jonthdiaz](https://twitter.com/jonthdiaz)
+
+Los códigos y tutoriales están como código abierto en GitHub: [github.com/AmazingAng/WTFSolidity](https://github.com/AmazingAng/WTFSolidity)
+
+-----
+
+## Sobrecarga
+`solidity` permite la sobrecarga de funciones (`overloading`). Es decir, funciones con el mismo nombre pero diferentes tipos de parámetros de entrada pueden existir al mismo tiempo, 
+y se consideran funciones diferentes.
+Note que `solidity` no permite la sobrecarga de modificadores (`modifier`).
+
+### Sobrecarga de Funciones
+Por ejemplo, se podría definir dos funciones llamadas `saySomething()`:
+una sin argumentos y que devuelva `"Nothing"`, la otra que tome un argumento de tipo `string` y devuelva un `string`.
+
+```solidity
+function saySomething() public pure returns(string memory){
+    return("Nothing");
+}
+
+function saySomething(string memory something) public pure returns(string memory){
+    return(something);
+}
+```
+
+Después de compilar, todas las funciones de sobrecarga se convierten en selectores de funciones diferentes debido a los diferentes tipos de parámetros.
+Para ver el contenido específico del selector de una función, consultar [WTF Solidity Tutorial: 29. Function Selector](https://github.com/AmazingAng/WTFSolidity/tree/main/29_Selector)
+
+Tomando el contrato `Overloading.sol` como ejemplo, después de compilar y desplegar en Remix.
+Después de llamar a las funciones de sobrecarga `saySomething()` y `saySomething(string memory something)` respectivamente,
+se pueden ver diferentes resultados, ya que las funciones se consideran diferentes.
+
+![](./img/16-1.jpeg)
+
+### Coincidencia de Argumentos
+
+Cuando se llama a la función de sobrecarga, el tipo de variable se emparejará entre el parámetro de entrada y los parámetros de la función.
+Se generará un error si hay múltiples funciones de sobrecarga coincidentes,
+El siguiente ejemplo tiene dos funciones llamadas `f()`, una tiene el parámetro `uint8` y la otra tiene `uint256`:
+
+```solidity
+    function f(uint8 _in) public pure returns (uint8 out) {
+        out = _in;
+    }
+
+    function f(uint256 _in) public pure returns (uint256 out) {
+        out = _in;
+    }
+```
+El número `50` se puede convertir tanto a `uint8` como a `uint256`, por lo que se generará un error si se llama a `f(50)`.
+
+## Resumen
+En esta lección, se presento el uso básico de la función de sobrecarga en `solidity`:
+las funciones con el mismo nombre pero diferentes tipos de parámetros de entrada pueden existir al mismo tiempo,
+y se consideran funciones diferentes.

Languages/es/17_Libreria_es/Library.sol

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.21;
+
+library Strings {
+    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
+
+    /**
+     * @dev Convierte un `uint256` a su representación decimal ASCII `string`.
+     */
+    function toString(uint256 value) public pure returns (string memory) {
+        // Inspirado en la implementación de OraclizeAPI - licencia MIT
+        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
+
+        if (value == 0) {
+            return "0";
+        }
+        uint256 temp = value;
+        uint256 digits;
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+        bytes memory buffer = new bytes(digits);
+        while (value != 0) {
+            digits -= 1;
+            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
+            value /= 10;
+        }
+        return string(buffer);
+    }
+
+    /**
+     * @dev Convierte un `uint256` a su representación hexadecimal ASCII `string`.
+     */
+    function toHexString(uint256 value) public pure returns (string memory) {
+        if (value == 0) {
+            return "0x00";
+        }
+        uint256 temp = value;
+        uint256 length = 0;
+        while (temp != 0) {
+            length++;
+            temp >>= 8;
+        }
+        return toHexString(value, length);
+    }
+
+    /**
+     * @dev Convierte un `uint256` a su representación hexadecimal ASCII `string` con longitud fija.
+     */
+    function toHexString(uint256 value, uint256 length) public pure returns (string memory) {
+        bytes memory buffer = new bytes(2 * length + 2);
+        buffer[0] = "0";
+        buffer[1] = "x";
+        for (uint256 i = 2 * length + 1; i > 1; --i) {
+            buffer[i] = _HEX_SYMBOLS[value & 0xf];
+            value >>= 4;
+        }
+        require(value == 0, "Strings: insuficiente longitud hexadecimal");
+        return string(buffer);
+    }
+}
+
+
+// Llamando a otro contrato de biblioteca con una función
+contract UseLibrary{    
+    // Usando la biblioteca con el comando "using for" 
+    using Strings for uint256;
+    function getString1(uint256 _number) public pure returns(string memory){
+        // Las funciones de la biblioteca se agregan automáticamente como miembros de las variables de tipo uint256
+        return _number.toHexString();
+    }
+
+    // Llamado directamente por el nombre del contrato 
+    function getString2(uint256 _number) public pure returns(string memory){
+        return Strings.toHexString(_number);
+    }
+}