Desplegando contrato en testnet con dev-accounts

Clase 21 de 24 • Curso de Desarrollo en NEAR Blockchain con Rust

Clase anteriorSiguiente clase

Fernando Piñango

student•

si al hacer el comando

cargo build --target wasm32-unknown-unknown --release

no se les genera el archivo .wasm

sino solo archivos .d y .rlib

intenten esto:

primero el comando solito: cargo build

luego el comando completo con el target: cargo build --target wasm32-unknown-unknown --release

Nicolás Montanari

student•

No compila, el compilador me dice "no matching pakage named 'parity-secp256k1' found". Estoy buscando soluciones. A alguien mas le pasó?

Yilson Contreras

student•

yo probé usando estas dependencias

[dependencies]near-sdk = "5.4" [dev-dependencies]near-sdk = { version = "5.5", features = ["unit-testing"] }near-workspaces = { version = "0.14.1", features = ["unstable"] }tokio = { version = "1.12.0", features = ["full"] }serde_json = "1"

Eber Laurente Lliuyacc

student•

Profesor, después de la compilación no se genera el archivo .wasm. Se genera le .d y .rlib, pero no el .wasm

Uso las siguientes dependencias

[lib]
create-type = ["cdylib", "rlib"]

[dependencies]
near-sdk = "4.0.0"
```

Código:

```
use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
use near_sdk::collections::UnorderedMap;
use near_sdk::serde::{Deserialize, Serialize};
use near_sdk::{near_bindgen, env, Promise, AccountId};

// near_sdk::setup_alloc!();
/****************  Estructura de Meme  ****************
Implementamos serde cuando necesitamos retornar la estructura serializada a JSON, util en NEAR, CLI y frontend. En este caso se utiliza ambas serializaciones (JSON y Borsh), usamos Borsh en la serialización de la blockchain de NEAR
*/
#[derive(Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
#[serde(crate = "near_sdk::serde")]
pub struct Meme{
  pub id: u64,
  pub creado_por: AccountId,
  pub titulo: String,
  pub museo: String,
  pub url: String,
  pub donaciones: u128,
}

// Implementación del trait default para inicializar la estructura de Meme
impl Default for Meme {
  fn default() -> Self {
    Meme { 
      id: 0, 
      creado_por: "".parse().unwrap(),//String::from(""), 
      titulo: String::from(""), 
      museo: String::from(""), 
      url: String::from(""), 
      donaciones: 0,
    }  
  }
}

// Implementación del metodo new que permite crear nuevos memes
impl Meme {
  pub fn new(titulo: String, url: String, museo: String) -> Self {
    Self { 
      // id y creado_por necesitan ser obtenidos desde la blockchain
      // id: 0, 
      // creado_por: String::from(""), 
      id: env::block_height(),
      creado_por: env::signer_account_id(),
      titulo, 
      museo, 
      url, 
      donaciones: 0, 
    }
  }
}

// State del contrato e inicialización de los valores por defacult
#[near_bindgen]
#[derive(BorshDeserialize, BorshSerialize)]
pub struct SimpleMemeMuseum{
  // Guardamos solo los ID para evitar editar en ambos lados
  museos: UnorderedMap<String, Vec<u64>>,
  memes: UnorderedMap<u64, Meme>,
}

// Inicialización de state del contrato
impl Default for SimpleMemeMuseum {
  fn default() -> Self {
    Self { 
      museos: UnorderedMap::new(b"u".to_vec()),
      memes: UnorderedMap::new(b"e".to_vec())
    }
  }
}

#[near_bindgen]
impl SimpleMemeMuseum {
  pub fn crear_meme(&mut self, titulo: String, url: String, nombre_museo: String){
    let meme = Meme::new(
      String::from(&titulo), 
      String::from(&url), 
      String::from(&nombre_museo),
    );

    //guardamos en una coleccion de memes
    self.memes.insert(&meme.id,&meme);

    //buscamos si el museo existe para despues añadir el meme en este.
    let museo = self.museos.get(&nombre_museo);
    if museo.is_some(){
      //m almacena el valor de some() del option<> o panic
      let mut m = museo.unwrap();
      m.push(meme.id);
      //insertamos en la colección de museos el museo y meme ligado a este
      self.museos.insert(&nombre_museo, &m);
    }
    else {
      let mut nuevo_museo = Vec::new();

      nuevo_museo.push(meme.id);
      self.museos.insert(&nombre_museo, &nuevo_museo);
    }

    //manda un mensaje a la terminal al ejecutar el método
    env::log_str(
      format!(
        "Nuevo meme añadido con éxito. Museo: {}, Id Meme: {}", 
        &nombre_museo, meme.id
      )
      .as_ref(),
    );
  }

  pub fn obtener_meme(&self, id: u64) -> Option<Meme>{
    self.memes.get(&id)
  }

  pub fn obtener_lista_memes(&self) -> Vec<(u64, Meme)> {
    self.memes.to_vec()
  }

  pub fn obtener_lista_museos(&self) -> Vec<String> {
    self.museos.keys_as_vector().to_vec()
  }

  pub fn obtener_memes_museo(&self, nombre_museo: String) -> Vec<Meme> {
    let museo = self.museos.get(&nombre_museo);
    if museo.is_some(){
      let mut lista_memes = Vec::new();
      for meme_id in &museo.unwrap() {
        let meme = self.memes.get(meme_id);
        if meme.is_some() {
          lista_memes.push(meme.unwrap());
        }
      }
      return lista_memes;
    }else{
      // env::log_str("No existe el museo ingresado").as_bytes();
      return Vec::new();
    }
  }

  #[payable]
  pub fn donar_a_meme(&mut self, id: u64) -> bool {
    assert!(
      env::attached_deposit() > 0,
      "Debes de agregar NEAR para hacer una donación"
    );

    //buscamos meme
    match self.memes.get(&id) {
      Some(mut meme) => {
        //si existe guardamos la donación en el registro
        meme.donaciones += env::attached_deposit();
        self.memes.insert(&meme.id, &meme);

        //Y transferimos la donación al creador del meme
        Promise::new(meme.creado_por)
        .transfer(env::attached_deposit());

        true
      }
      None => false,
    }
  }
}
```

Juan David Díaz Pastrana

student•

Eso puede ocurrir al no ponerle el target a cargo

Fernando Piñango

student•

me pasa lo mismo,

cargo build --target wasm32-unknown-unknown --release

alguna solucion?

Edward Rodriguez

student•

Para el problema del balance al momento de hacer el deploy, pueden usar un faucet:

https://jelilat.github.io/near-faucet/

Desplegando contrato en testnet con dev-accounts

Introducción a NEAR

Bienvenida al desarrollo con NEAR

¿Por qué NEAR?

De la web2 a la web3 con NEAR

¿Qué es una cuenta en NEAR?

Access keys

Conozcamos la NEAR Wallet

Data Storage y Storage Staking

Gestión de contratos en NEAR

Métodos view y change

Gas

Redes en NEAR

Runtime, transacciones y ciclo de una transacción

Ambiente de desarrollo en Rust para NEAR

Montar ambiente de WebAssembly en Rust

Explorando la NEAR CLI

Un vistazo al NEAR Explorer

Desarrollo en NEAR con Rust

Desplegar y testear el proyecto del curso

Estructura de un contrato inteligente

Colecciones de datos en NEAR

Módulo env de NEAR

Mutabilidad de un contrato

Métodos payables y promises

Desplegando el contrato

Desplegando contrato en testnet con dev-accounts

Invocando al contrato con el NEAR CLI

Ve mas allá

Aurora la EVM de NEAR

Conclusión