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/