V2

README.md

@@ -1,12 +1,4 @@
-# Recommendation
-The following is not necessary and you should be able to work properly without following this, but we recommend to avoid implementing the `Default` trait since in most cases we will not have a Default contract, but we will have some initialization params. So for this case, check how we change the Default trait for a simple implementation using the `init` macro and define the `new` function on the `src/lib.rs` file.
+# Sobre el proyecto
+En este proyecto vamos a aprender a hacer contratos de NEAR con rust. Para esto, se aconseja seguir las instrucciones que se dan en los distintos archivos dentro de la carpeta `readmes/`. Están nombrados por versión, donde en cada caso se enseña algo nuevo.
 
-We will also change the contract name for a more logic one.
-
-In case you'd rather still use the Default, we recommend for the purpose of this tutorial to still do it and try doing the same with just the `Default` trait, since all the following code will have this change done.
-
-We will also add to our Cargo.toml file into our dependencies the following line `borsh = "1.5.1"`. Borsh means `Binary Object Representation Serializer for Hashing` and will help us serialize and deserialize objects in order to improve storing data on the blockchain and recovering it. We want to do this for faster execution time and save storage cost.
-
-We will also need to adapt our tests for this new structure, but the code contract will remain the same way.
-
-After making all the fixes, we will need to build our project again by running `cargo build` and checking we have no error.
+Para cada readme hay un branch con el nombre correspondiente. En cada branch, se hacen los cambios que se describen en el readme, agregando archivos y cambiando o agregando código. Se aconseja empezar con el instructivo en el branch v1 y seguir a partir de ahí.

readmes/v1.md

@@ -0,0 +1,56 @@
+# Bienvenidos
+Bienvenidos a este tutorial para aprender a hacer tu propio contrato de NEAR utilizando rust.
+
+Para este tutorial, vamos a utilizar la versión 1.80.1 de rustc
+
+En este tutorial, se va a asumir cierto nivel de conocimiento y que se tienen ciertas cosas instaladas, como node y un manejo básico del mismo.
+
+## Instalando los paquetes necesarios
+### Rust
+Para instalar rust, sigan las instrucciones en el [sitio oficial de rust](https://www.rust-lang.org/tools/install)
+
+Esto va a instalar la versión más reciente de rust. En este momento, NEAR está teniendo ciertos problemas con la versión más reciente de rust. Por esto, les recomendamos que bajen la versión de rust para este tutorial de la siguiente forma:
+
+```
+rustup install 1.80.1
+rustup default 1.80.1
+```
+
+Pueden verificarlo corriendo `rustc --version`
+
+### Otros paquetes
+Pueden seguir las siguientes instrucciones en la [documentación de NEAR](https://docs.near.org/smart-contracts/quickstart). En caso que el contenido de la página cambie, se pegan los comandos más relevantes abajo.
+
+```
+# Contracts will be compiled to wasm, so we need to add the wasm target
+rustup target add wasm32-unknown-unknown
+
+# Install NEAR CLI-RS to deploy and interact with the contract
+curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/near-cli-rs/releases/latest/download/near-cli-rs-installer.sh | sh
+
+# Install cargo near to help building the contract
+curl --proto '=https' --tlsv1.2 -LsSf https://github.com/near/cargo-near/releases/latest/download/cargo-near-installer.sh | sh
+```
+
+## Inicializar el código del contrato
+Con el siguiente comando vamos a tener un contrato básico de NEAR listo para ser deployado con unos tests básicos. Esto también nos va a generar una carpeta `hello-near`.
+```
+cargo near new hello-near
+```
+
+Luego de esto, podemos verificar en `src/lib.rs` nuestro contrato con las funciones set_greeting y get_greeting y sus tests correspondientes.
+
+## Testear tu contrato
+Además de los tests unitarios mencionados, tenemos un test más en `tests/test_basics.rs`. Si queremos correr los tests, podemos hacerlo simplemente corriendo:
+```
+cargo test
+```
+
+Luego de correr este comando, el código será compilado en la carpeta `target/` en la raiz del proyecto. Noten que esta carpeta ya está incluida en el archivo `.gitignore`, por lo que no es necesario ni conveniente subir esta carpeta a github, ya que se puede generar con mucha facilidad.
+
+Hay 2 tipos de tests en rust:
+- Tests en el archivo: los tests son escritos en el mismo archivo que tienen las funciones que deben ser testeadas
+- Tests de integración: generalmente escritos en la carpeta `tests/` que se encuentra en la raiz del proyecto y deberían testear todo el contrato.
+
+## ¿Qué más es importante?
+También tenemos el archivo `Cargo.toml` que es como el `package.json` en node. Podemos incluir cierta configuración y nuestras dependencias. Podemos buscar dependencias en `https://crates.io/`.

readmes/v2.md

@@ -0,0 +1,14 @@
+# Recomendación
+Lo siguiente no es necesario per se y se debería poder trabajar apropiadamente sin seguir esto, pero recomendamos evitar implementar el trait `Default`, ya que en general, no vamos a querer tener un contrato con valores por defecto, sino que vamos a elegir nuestros parámetros a la hora de inicializarlo.
+
+Así que para este caso, les recomendamos que cambien el trait Default por una simple implementación utilizando el macro `init` y definir la función `new` en el archivo `src/lib.rs`.
+
+También vamos a cambiar el nombre del contrato por uno más lógico.
+
+En caso de que prefieran seguir utilizando el trait Default, les aconsejamos que lo hagan luego de seguir el tutorial, con todo lo que aprendan, ya que el tutorial va a seguir asumiendo que esto no está y no vamos a poder garantizar que todo funcione exactamente igual, aunque es posible que si lo haga.
+
+También vamos a añadir en nuestro archivo Cargo.toml, en nuestras dependencias, la siguiente linea `borsh = "1.5.1"`. Borsh significa `Binary Object Representation Serializer for Hashing` y nos va a ayudar a serializar y deserializar objetos para mejorar el guardado y recuperación de información en la blockchain, de forma más rápida y utilizando el menor espacio de guardado posible.
+
+También necesitaremos adaptar nuestros tests a esta nueva estructura, pero el código del contrato, quedará igual.
+
+Luego de hacer estos arreglos, podremos buildear nuestro proyecto nuevamente corriendo `cargo build` y chequear que no haya error.