ETHEREVOLUTION: INSIEME NEL FUTURO

Menu
Home » Smart contract » Capire Vyper: il nuovo linguaggio scaltro di Ethereum (PT2)

Capire Vyper: il nuovo linguaggio scaltro di Ethereum (PT2)

15 Agosto 2018 12:59
Tempo di lettura: 5 min.
15 Agosto 2018 12:59
Emanuele

Questa è la seconda parte di un’ articolo pubblicato due giorni fa che potete trovare qui.

Constructor Functions

I constructor functions seguono le stesse convenzioni di Python e istanziano un determinato contratto e relativi parametri sulla blockchain.

L’init inizializza il programma e viene eseguito soltanto una volta. Per esempio :

@public def __init__(_name: bytes32, _decimals: uint256, _initialSupply: uint256): self.name = _name self.decimals = _decimals self.totalSupply = uint256_mul(_initialSupply, uint256_exp(convert(5, ‘uint256’), _decimals))

Come con Python, il self è utilizzato per definire variabili dell’istanza eseguita.

La funzione qua sopra è “decorata” con il @public decorator per dare ad esso la visibilità pubblica e permettere ai soggetti esterni di richiederlo (al contrario di quello predefinito – o lasciando fuori il decorator – che è privato).

Il decorator @constant è utilizzato per “decorare” metodi che leggono soltanto uno state, mentre @payable rende ogni metodo capace di venire richiesto con un pagamento.

Eventi

Potrete accedere agli eventi utilizzando _log_in strutture indicizzate, così:

payment: __log__({amount: uint256, param2: indexed(address)}) tot_payment: uint256 @public def pay():

self.tot_payment += msg.value log.payment(msg.value, msg.sender)

Scrivere Contratti per Vyper

Adesso scriviamo un paio di semplici Smart Contract. Il frammento di codice che segue permette al contratto di ricevere un NFT (non-fungible token) ed essere in grado di inviare quel token.

@public def safeTransferFrom(_from: address, _to: address, _tokenId: uint256):

self._validateTransferFrom(_from, _to, _tokenId, msg.sender) self._doTransfer(_from, _to, _tokenId) if(_to.codesize > 0):

returnValue: bytes[4] = raw_call(_to, 'xf0xb9xe5xba', outsize=4, gas=msg.gas)

assert returnValue == 'xf0xb9xe5xba'

Il seguente mostra il @public decorator, definendo una funzione con un singolo parametro, al quale viene dato esplicitamente un type e un codice molto semplice nel body utilizzando degli assert per verificare se un utente ha il diritto di votare come parte di un programma di “votazione con delegazione” :

# Give a voter the right to vote on this ballot # This may only be called by the chairperson @public def give_right_to_vote(voter: address):

assert msg.sender == self.chairperson # throw if sender is not chairperson assert not self.voters[voter].voted # throw if voter has already voted assert

self.voters[voter].weight == 0 # throw if voter's voting weight isn't 0

self.voters[voter].weight = 1 self.voter_count += 1

Una volta che abbiamo discusso le distinzioni sintattiche e logiche, il codice non è più così intimidatorio.

Vyper.online rende disponibile l’intero codice sorgente per il programma di “votazione con delega”, utilizzando strutture per elettori e proposte e le seguenti che vengono chiamate:

def delegated(addr: address) -> bool def directly_voted(addr: address) -> bool def __init__(_proposalNames: bytes32[2]) def give_right_to_vote(voter: address) def forward_weight(delegate_with_weight_to_forward: address) def delegate(to: address) def vote(proposal: int128) def winning_proposal() -> int128 def winner_name() -> bytes32

Come con qualsiasi linguaggio di programmazione, progettare i costrutti principali (in questo caso, i function contract) in anticipo rende la programmazione molto più facile.

La principale differenza che riguarda Vyper da tenere a mente è la mancanza di paradigmi OOP.

Nell’attuale fase di sviluppo, non potete ancora effettuare chiamate via codice verso l’esterno.

Le considerazioni per consentire chiamate esterne possono essere visualizzate della seguente proposta di sviluppo:

#External contract A:

def foo(): constant def bar(): modifying # This contract contract B: a: A def baz(): a.foo() a.bar()

Dove il contract b richiama il contract A, includendo modalità all’interno di A, nell’esempio più semplice possibile.

Utilizzare Vyper

Per eseguire la scrittura del codice, andate su vyper.online e scrivete gli esempi di codice sotto la scheda “Source Code” e cliccate “Compile” una volta pronti.

Il client più utilizzato (sebbene nella pre-alpha) per l’attuazione di Vyper e l’esecuzione del test è Py-EVM, sviluppato inizialmente dallo stesso Vitalik, che consente all’utente di aggiungere gli opcode o modificare quelli già esistenti senza cambiare la libreria di codice, permettendo maggiore modularità ed estensibilità rispetto ad un client comune.

Per avere Py – EVM, utilizzate pip install py-evm==0.0.a16.

3a. Sviluppare i vostri Contratti Vyper

Mentre Py-EVM è momentaneamente in pre-alpha e potrebbe essere difficile metterlo in funzione, ci sono due alternative più semplici per sviluppare contratti Vyper verso testnet pubbliche (ed un bonus):

Incollate il bytecode generato da vyper.online all’interno di Mist o geth
Utilizzate il menu “contratto” su myetherwallet per sviluppare nel browser corrente
(imminente)

In futuro, Vyper si integrerà con populus, permettendovi di utilizzare facilmente i contratti di Vyper.

Per semplificare, utilizzeremo contratti che usano l’opzione (1) e Mist. Dal momento che Vyper è conforme allo stesso Bytecode di Solidity, non abbiamo bisogno di alcun client specifico di Vyper e possiamo seguire questi step alquanto indiretti:

Andare su vyper.online e cliccate su “Compile” sul “Source Code” di votazione pre-compilato
Copiare tutto sotto la scheda “Bytecode”
Installare Mist per il vostro OS, se non lo avete già fatto
Consentire al node di scaricare e sincronizzare (questo succede automaticamente)
Selezionare “USE THE TEST NETWORK” nella configurazione di Mist
Creare una password
Inserire il Contratto
Selezionare “Contracts” nell’interfaccia di Mist
Selezionare “DEPLOY NEW CONTRACTS”
Andare nella scheda “CONTRACT BYTE CODE”
Incollare il bytecode che avete copiato da vyper.online

Rilasciare il Contratto

Selezionare “DEPLOY” e inserire la password precedente
Confermare che il contratto di Vyper sia stato installato
Andare nella scheda “Wallets” su Mist
Scorrere giù fino a “Latest Transactions”
Dovreste vedere il contratto che avete appena rilasciato sebbene nello stato “Creating Contract” poiché non è stato minato e validato

Conclusione

Questa guida fornisce un’introduzione logica e sintattica a Vyper, permettendoci di iniziare a programmare ed installare contratti.

Con le informazioni presenti in questa guida, dovreste essere in grado di contribuire allo sviluppo di Vyper, alla sua documentazione e a continuare ad imparare facendo coding su vyper.online.

Di nuovo, Vyper non è stato fatto per rimpiazzare Solidity, ma siccome uno studio ha trovato oltre 34,000 contratti vulnerabili, la necessità per una maggiore sicurezza in questo spazio è più grande che mai, conferendo a Vyper un futuro importante su Ethereum.

Di: blockgeeks

Clicca qui per accedere alla guida gratuita su come comprare, vendere, trasferire e conservare in sicurezza gli Ether.

Condividi
  • 57
    Shares

Articoli che potrebbero interessarti

13 Agosto 2018

Capire Vyper: il nuovo linguaggio scaltro di Ethereum (PT1)

Vyper è un linguaggio di programmazione sperimentale compilabile fino al bytecode...

Leggi tutto

CATEGORIE:

Smart contract


Emanuele

Crypto-lover. Nerd fin dal principio. Ama analizzare numeri, grafici e andamenti. Crea statistiche anche dove non necessario.


Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *

Condividi questo articolo

Invia questo articolo ad un amico