Considerato uno dei linguaggi più stabili, completi ed affidabili per costruire sistemi complessi, sono circa 5 miliardi le schede Java in uso. Per le sue caratteristiche e la sua popolarità — vi sono circa 9 milioni di sviluppatori Java in tutto il mondo — questo linguaggio è utilizzato anche nel settore blockchain per la programmazione e lo sviluppo dell’infrastruttura peer-to-peer.
Una blockchain interamente costruita su questo linguaggio è Takamaka, piattaforma di terza generazione che consente la gestione simultanea di due monete digitali: il token verde (TKG) e il token rosso (TKR).
Che cos’è Takamaka?
Takamaka è un framework Java per scrivere smart contract (contratti intelligenti). Ciò significa che consente di utilizzare Java per scrivere codice installabile ed eseguibile su
una blockchain. I programmatori non dovranno occuparsi dell'archiviazione di oggetti in blockchain: questo è per loro completamente trasparente.
Come spiegato sul sito ufficiale del progetto, Takamaka è una blockchain Java Full Stack. Questo indica che Java è l'unico codice utilizzato per la programmazione e l'amministrazione dell'intera infrastruttura: dalla gestione dei nodi agli smart contract. Ci sono, ovviamente, limitazioni al tipo di codice che può essere eseguito all'interno di una blockchain, quella più importante è il comportamento deterministico.
Per sviluppare una blockchain in Java, un programmatore può utilizzare il suo ambiente di sviluppo integrato (IDE) preferito per Java o lavorare direttamente dalla riga di comando.
La nozione di smart contract
Uno smart contract è un accordo legale tra due o più parti. Un buon contratto dovrebbe essere inequivocabile altrimenti la sua interpretazione potrebbe essere messa in dubbio o fraintesa. Un sistema legale impone normalmente la validità di un contratto. Nel contesto dello sviluppo software, uno smart contract è una porzione di software con comportamento deterministico, la cui semantica dovrebbe essere chiara e applicata da un sistema di consenso.
La blockchain fornisce l'ambiente ideale in cui è possibile implementare ed eseguire contratti intelligenti, poiché la loro natura decentralizzata riduce il rischio che una singola parte rovesci le regole del consenso, fornendo, ad esempio, una semantica non standard per lo smart contract.
Gli Smart Contract possono detenere e trasferire denaro ad altri contratti. Quindi, tradizionalmente, i contratti intelligenti si dividono in quelli che contengono denaro ma non hanno codice (account di proprietà esterna) e quelli che invece contengono codice (contratti intelligenti). I primi sono tipicamente controllati da un agente esterno (un portafoglio, un essere
umano) mentre i secondi sono tipicamente controllati dal loro codice.
La blockchain Takamaka implementa entrambe le alternative come istanze della classe della libreria astratta takamaka.lang.Contract (all'interno di takamaka_base.jar). Tale classe estende takamaka.lang.Storage quindi le sue istanze possono essere mantenute in blockchain. La libreria Takamaka definisce sottoclassi di takamaka.lang.Contract e i programmatori possono definire le proprie sottoclassi.
Di seguito presentiamo un semplice smart contract il cui obiettivo è imporre uno schema di investimento Ponzi: ogni investitore ripaga l'investitore precedente con almeno un 10% di ricompensa. Finché continuano ad arrivare nuovi investitori ognuno di essi ottiene almeno la percentuale prevista, l'ultimo investitore, invece, non vedrà mai indietro il proprio investimento. Il contratto è stato ispirato da un contratto Ethereum simile di Iyer e Dannen, Building Games with Ethereum Smart Contracts, pagina 145, Apress 2018.
Un semplice contratto di schema Ponzi
Per poter procedere con la creazione di questo smart contract si comincia con lo sviluppo di un nuovo progetto Ponzi Java in Eclipse. Successivamente si creano le cartelle lib e dist all'interno del progetto inserendo takamaka_base.jar e takamaka_runtime.jar all'interno di lib, che verranno aggiungiti al percorso di compilazione dello schema Ponzi.
Da qui si crea il pacchetto takamaka.tests.ponzi, una classe SimplePonzi.java all'interno di quel pacchetto e si copia il seguente codice in SimplePonzi.java:
package takamaka.tests.ponzi;
import static takamaka.lang.Takamaka.require;
import java.math.BigInteger;
import takamaka.lang.Contract;
public class SimplePonzi extends Contract {
private final BigInteger _10 = BigInteger.valueOf(10L);
private final BigInteger _11 = BigInteger.valueOf(11L);
private Contract currentInvestor;
private BigInteger currentInvestment = BigInteger.ZERO;
public void invest (Contract investor, BigInteger amount) {
// new investments must be 10% greater than current
BigInteger minimumInvestment =
currentInvestment.multiply(_11).divide(_10);
require(amount.compareTo(minimumInvestment) > 0, () -> "you must invest more than " + minimumInvestment);
// document new investor
currentInvestor = investor;
currentInvestment = amount;
}
}Osservando il codice di SimplePonzi.java si nota come il contratto ha un unico metodo denominato invest. Questo metodo consente a un nuovo investitore di investire un determinato quantitativo di monete. Questo importo deve essere almeno il 10% in più rispetto all'investimento attuale.
L'espressione amount.compareTo (minimumInvestment) > 0 è un confronto tra due Java BigInteger e va letta come la più familiare amount > minimumInvestment. Quest'ultima non può essere scritta in questa forma poiché Java non consente agli operatori di confronto di lavorare sui tipi di riferimento.
Il metodo statico takamaka.lang.Takamaka.require() può essere utilizzato per richiedere una precondizione da mantenere. La chiamata, require, genera un'eccezione se condition non tiene con il message dato.
Se il nuovo investimento è maggiore di almeno il 10% rispetto a quello attuale, verrà salvato nello stato del contratto insieme al nuovo investitore.
Nota per il lettore: questo codice è solo il punto di partenza della nostra discussione. La versione finale reale di questo contratto elaborata passo passo è stata completamente svolta e dettagliata qui.
